Real Python

Python's raise: Effectively Raising Exceptions in Your Code

2023-06-19T14:00:00+00:00

In your Python journey, you’ll come across situations where you need to signal that something is going wrong in your code. For example, maybe a file doesn’t exist, a network or database connection fails, or your code gets invalid input. A common approach to tackle these issues is to raise an exception, notifying the user that an error has occurred. That’s what Python’s raise statement is for.

Learning about the raise statement allows you to effectively handle errors and exceptional situations in your code. This way, you’ll develop more robust programs and higher-quality code.

In this tutorial, you’ll learn how to:

Raise exceptions in Python using the raise statement
Decide which exceptions to raise and when to raise them in your code
Explore common use cases for raising exceptions in Python
Apply best practices for raising exceptions in your Python code

To get the most out of this tutorial, you should understand the fundamentals of Python, including variables, data types, conditional statements, exception handling, and classes.

Free Bonus: Click here to download the sample code that you’ll use to gracefully raise and handle exceptions in your Python code.

Handling Exceptional Situations in Python

Exceptions play a fundamental role in Python. They allow you to handle errors and exceptional situations in your code. But what is an exception? An exception represents an error or indicates that something is going wrong. Some programming languages, such as C, and Go, encourage you to return error codes, which you check. In contrast, Python encourages you to raise exceptions, which you handle.

Note: In Python, not all exceptions are errors. The built-in StopIteration exception is an excellent example of this. Python internally uses this exception to terminate the iteration over iterators. Python exceptions that represent errors have the Error suffix attached to their names.

Python also has a specific category of exceptions that represent warnings to the programmer. Warnings come in handy when you need to alert the user of some condition in a program. However, that condition may not warrant raising an exception and terminating the program. A common example of a warning is DeprecationWarning, which appears when you use deprecated features.

When a problem occurs in a program, Python automatically raises an exception. For example, watch what happens if you try to access a nonexistent index in a list object:

>>>

>>> colors = [
...     "red",
...     "orange",
...     "yellow",
...     "green",
...     "blue",
...     "indigo",
...     "violet"
... ]

>>> colors[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range

In this example, your colors list doesn’t have a 10 index. Its indices go from 0 to 6, covering your seven colors. So, if you try to get index number 10, then you get an IndexError exception telling you that your target index is out of range.

Note: In the example above, Python raised the exception on its own, which it’ll only do with built-in exceptions. You, as a programmer, have the option to raise built-in or custom exceptions, as you’ll learn in the section Choosing the Exception to Raise: Built-in vs Custom.

Every raised exception has a traceback, also known as a stack trace, stack traceback, or backtrace, among other names. A traceback is a report containing the sequence of calls and operations that traces down to the current exception.

In Python, the traceback header is Traceback (most recent call last) in most situations. Then you’ll have the actual call stack and the exception name followed by its error message.

Note: Since the introduction of the new PEG parser in Python 3.9, there’s been an ongoing effort to make the error messages in tracebacks more helpful and specific. This effort continues to produce new results, and Python 3.12 has incorporated even better error messages.

Exceptions will cause your program to terminate unless you handle them using a try … except block:

>>>

>>> try:
...     colors[10]
... except IndexError:
...     print("Your list doesn't have that index :-(")
...
Your list doesn't have that index :-(

The first step in handling an exception is to predict which exceptions can happen. If you don’t do that, then you can’t handle the exceptions, and your program will crash. In that situation, Python will print the exception traceback so that you can figure out how to fix the problem. Sometimes, you must let the program fail in order to discover the exceptions that it raises.

In the above example, you know beforehand that indexing a list with an index beyond its range will raise an IndexError exception. So, you’re ready to catch and handle that specific exception. The try block takes care of catching exceptions. The except clause specifies the exception that you’re predicting, and the except code block allows you to take action accordingly. The whole process is known as exception handling.

If your code raises an exception in a function but doesn’t handle it there, then the exception propagates to where you called function. If your code doesn’t handle it there either, then it continues propagating until it reaches the main program. If there’s no exception handler there, then the program halts with an exception traceback.

Exceptions are everywhere in Python. Virtually every module in the standard library uses them. Python will raise exceptions in many different circumstances. The Python documentation states that:

Exceptions are a means of breaking out of the normal flow of control of a code block in order to handle errors or other exceptional conditions. An exception is raised at the point where the error is detected; it may be handled by the surrounding code block or by any code block that directly or indirectly invoked the code block where the error occurred. (Source)

In short, Python automatically raises exceptions when an error occurs during a program’s execution. Python also allows you to raise exceptions on demand using the raise keyword. This keyword lets you handle your program’s errors in a more controlled manner.

Raising Exceptions in Python: The `raise` Statement

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

[ 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 #160: Inheriting a Large Python Code Base & Building a GUI With Kivy

2023-06-16T12:00:00+00:00

What are the unique challenges of a large Python code base? What techniques can you implement to simplify the management of a big project? 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 Make Engaging Programming Videos

2023-06-14T14:00:00+00:00

Programming videos have become an increasingly popular medium for sharing knowledge and helping the fellow developers on your team. Especially when you’re working remotely, effective communication is vital, and screencasts have emerged as a powerful tool that meets this need. That’s why knowing how to make programming videos is a valuable skill, no matter where you are in your career.

Even if you’ve never considered creating video content yourself, creating a screencast can be a great way to enhance written documentation or demonstrate complex processes as a professional programmer. Often, a two-minute video helps your colleagues more than a wordy email. Other times, an in-depth thirty-minute video is more convincing than an hour-long meeting.

However, not all videos are equally effective. To create engaging and informative programming screencasts, you should keep some important details in mind.

In this tutorial, you’ll learn how to:

Know when the video format is the right choice
Set up your machine to record screencasts
Prepare the content and the code
Be a captivating programming instructor
Handle mistakes while filming
Export and share your video

In the end, you’ll be equipped with the knowledge and skills to produce screencasts that make a meaningful impact on your viewers.

If you’re using VS Code and want to have a distraction-free environment in your code editor while recording, then you can download a handy settings file for VS Code by clicking the link below:

Free Bonus: Click here to download the settings file that you can use to create a clean, readable VS Code editor for your programming video tutorials.

Decide When a Programming Video Makes Sense

Not every idea that you want to get across is worth recording a video for. But the more experienced you are with hitting the record button, the more convenient it’ll be to use the video format instead of writing.

There are three common tasks where a video can come in handy:

Showing off a new feature
Asking for help with a bug
Giving visual feedback on a program

While your desired outcome for each of these use cases is probably different, the preparation for each of them is quite similar. In this section, you’ll explore how to tackle a process that applies to all the tasks so you know what you want to talk about in your recording.

Focus on the Outcome

If you decide to create a programming video, then it’s important to focus on the outcome that you want to achieve. By clearly defining your desired outcome, you can structure your video in a way that effectively communicates the key points and ensures that your viewers gain the intended knowledge or understanding.

When showcasing key features, your objective could be to demonstrate the core functionality of a high-quality Python package or a new framework that you’re trying out. In these cases, you may want to provide step-by-step instructions and examples to help viewers understand and use the package effectively on their machines.

Other times, you may want to provide constructive feedback on the user interface of an application. For example, maybe you want to share your thoughts on the front end of a Flask API. Then your objective could be to highlight potential improvements, usability concerns, and design recommendations.

Another outcome of a screencast could be to guide viewers through the process of identifying a specific bug. This might include explaining the symptoms and potential causes then troubleshooting steps to narrow down and locate the issue effectively.

Some people are often more inclined to watch a short video instead of taking the same time to read. So if you’re looking for help in an online Python community, then a small screencast can be a great way to illustrate your problem.

Sketch Out Code Examples

Chances are that you’ll include some code in your programming videos. You may showcase snippets or perform live coding. Either way, it’s crucial to sketch out the code examples beforehand.

Preparing code examples allows you to iterate how you want to present your code before you start filming. Here are some ideas of how you can sketch out your code examples:

Plan the structure: Outline the code examples in advance to determine their logical structure and flow. This helps present the code coherently, making it easier for your viewers to follow along and understand the concepts that you explain.
Clarify your key points: Refine and clarify the key points that you want to convey. Identify and highlight crucial aspects of the code, ensuring that you address essential concepts and techniques effectively.
Ensure the code is correct: Test the code snippets beforehand to verify their correctness. This ensures that they produce the desired output or functionality during the recording, allowing you to deliver accurate and well-formatted Python code to your viewers.
Optimize for presentation: Optimize the code for presentation purposes by removing irrelevant segments, simplifying complex sections, or deleting unnecessary type annotations. This makes your Python code examples concise, focused, and readily comprehensible for your audience.

By preparing your code, you ensure that it’s clean, organized, and operational, resulting in a seamless and effective learning experience for your viewers.

Take Speaker Notes

Read the full article at https://realpython.com/how-to-make-programming-videos/ »

[ 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: Reading and Writing Files

2023-06-13T14:00:00+00:00

Files are everywhere in the modern world. They’re the medium in which data is digitally stored and transferred. Chances are, you’ve opened dozens, if not hundreds, of files just today! Now it’s time to read and write files with Python.

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

Understand the difference between text and binary files
Learn about character encodings and line endings
Work with file objects in Python
Read and write character data in various file modes
Use open(), Path.open(), and the with statement
Take advantage of the csv module to manipulate CSV data

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.

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 ]

Python News: What's New From May 2023

2023-06-12T14:00:00+00:00

May 2023 was an important month for Python, as the upcoming Python 3.12 version is now feature complete. You can dig into a lot of information about Python and its development by reading the coverage of the Language Summit and watching videos from PyCon US. Modular has announced a new programming language that’s based on Python.

Grab a cup of your favorite beverage and sit down with the most important Python news from the last month.

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

Python 3.12 in Beta

Since 2019, a new version of Python has been released every year in October. The next version of Python–Python 3.12—is no different. Its release is planned for October 2, 2023.

Python 3.12 reached an important milestone last month when its first beta version was released. A beta release is an early release of an upcoming Python version. In contrast to alpha releases, which have been available for a while, the betas are feature complete.

Being feature complete means that there’ll be no features added to Python 3.12 that aren’t already in the beta version. Instead, the time until the final release in October will focus on finding and fixing bugs and other issues. The core developers ask for your help:

We strongly encourage maintainers of third-party Python projects to test with 3.12 during the beta phase and report issues found to the Python bug tracker as soon as possible. (Source)

You should install the beta version and test that your code still works. Finding bugs during the beta phase is an important and impactful way to contribute to Python. If you maintain a package on PyPI, then you can help the community by running tests and publishing wheels for Python 3.12.

You can learn about all the upcoming features from What’s New in Python 3.12. Some highlights are the following:

Ever better error messages
More powerful f-strings
Better support for sub-interpreters
Improved static typing features
Support for the Linux perf profiler

In addition, the Faster CPython project continues to deliver performance improvements, and Python 3.12 will be even faster than Python 3.11.

Read the full article at https://realpython.com/python-news-may-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 #159: Volunteering, Organizing, and Finding a Python Community

2023-06-09T12:00:00+00:00

Have you thought about getting more involved in the Python community? Are you interested in volunteering for an event or becoming an organizer? This week on the show, we speak with organizers from this year's PyCascades conference about making connections, learning new skills, and rationing your time.

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

What's the Zen of Python?

2023-06-07T14:00:00+00:00

If you’ve been learning Python long enough, then you’ve likely seen or heard about the Zen of Python. Experienced Pythonistas often refer to it as a source of wisdom and guidance, especially when they want to settle an argument about certain design decisions in a piece of code. Others take these principles even more seriously by considering them a sort of Pythonic decalogue.

In this tutorial, you’ll learn where to find the Zen of Python, how it came into existence, and how to interpret its mysterious aphorisms. You don’t need to be a Python master to understand the Zen of Python! But you do need to answer an important question: What exactly is the Zen of Python?

Free Bonus: Click here to download your Easter egg hunt to discover what’s hidden inside Python!

In Short: It’s a Humorous Poem Listing Python Philosophies

According to the Python glossary, which contains definitions of popular terms related to this programming language, the Zen of Python is a:

Listing of Python design principles and philosophies that are helpful in understanding and using the language. The listing can be found by typing “import this” at the interactive prompt. (Source)

Indeed, when you type the indicated import statement into an interactive Python REPL, then you’ll be presented with the nineteen aphorisms that make up the Zen of Python:

>>>

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

The byline reveals the poem’s author, Tim Peters, who’s a renowned software engineer and a long-standing CPython core developer best known for inventing the Timsort sorting algorithm. He also authored the doctest and timeit modules in the Python standard library, along with making many other contributions.

Take your time to read through the Zen of Python and contemplate its wisdom. But don’t take the aphorisms literally, as they’re more of a guiding set of principles rather than strict instructions. You’ll learn about their humorous origins in the next section.

How Did the Zen of Python Originate?

The idea of formulating a single document that would encapsulate Python’s fundamental philosophies emerged among the core developers in June 1999. As more and more people began coming to Python from other programming languages, they’d often bring their preconceived notions of software design that weren’t necessarily Pythonic. To help them follow the spirit of the language, a set of recommendations for writing idiomatic Python was needed.

The initial discussion about creating such a document took place on the Python mailing list under the subject The Python Way. Today, you can find this conversation in the official Python-list archive. If you look closely at the first message from Tim Peters in that thread, then you’ll notice that he clearly outlined the Zen of Python as a joke. That original form has stuck around until this day:

Clearly a job for Guido alone – although I doubt it’s one he’ll take on (fwiw, I wish he would too!). Here’s the outline he would start from, though <wink>:

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

There you go: 20 Pythonic Fec^H^H^HTheses on the nose, counting the one I’m leaving for Guido to fill in. If the answer to any Python design issue isn’t obvious after reading those – well, I just give up <wink>. (Source)

The wink and the playful way of self-censoring some toilet humor are clear giveaways that Tim Peters didn’t want anyone to take his comment too seriously.

Note: In case you didn’t get the joke, he started to write something like Feces but then used ^H—which represents a Backspace in older text editors like Vim—to delete the last three letters and make the word Theses. Therefore, the intended phrase is 20 Pythonic Theses.

Eventually, these nearly twenty theses got a proper name and were formally codified in a Python Enhancement Proposal document. Each PEP document receives a number. For example, you might have stumbled on PEP 8, which is the style guide for writing readable Python code. Perhaps as an inside joke, the Zen of Python received the number PEP 20 to signify the incomplete number of aphorisms in it.

To win your next argument about what makes good Python code, you can back up your claims with the Zen of Python. If you’d like to refer to a specific aphorism instead of the entire poem, then consider visiting pep20.org, which provides convenient clickable links to each principle.

And, in case you want to learn the poem by heart while having some fun, you can now listen to a song with the Zen of Python as its lyrics. Barry Warsaw, another core developer involved with Python since its early days, composed and performed this musical rendition. The song became the closing track on a special vinyl record entitled The Zen Side of the Moon, which was auctioned at PyCon US 2023.

Okay. Now that you have a rough idea of what the Zen of Python is and how it came about, you might be asking yourself whether you should really follow it.

Should You Obey the Zen of Python?

Read the full article at https://realpython.com/zen-of-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 ]

Mazes in Python Part 1: Building and Visualizing

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

If you’re up for a little challenge and would like to take your programming skills to the next level, then you’ve come to the right place! In this hands-on video course, you’ll practice object-oriented programming, among several other good practices, while building a cool maze solver project in Python.

This is the first part in a two-part series. Throughout the series, you’ll go step by step through the guided process of building a complete and working project. This will include reading a maze from a binary file, visualizing it using scalable vector graphics (SVG), and finding the shortest path from the entrance to the exit.

In part one of the series, you’ll learn how to:

Use an object-oriented approach to represent the maze in memory
Visualize the maze and its solution using scalable vector graphics (SVG)

In the next part of the series, you’ll complete the project by creating a binary storage format for mazes and solving mazes using NetworkX.

[ 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 NumPy Random Number Generator

2023-06-05T14:00:00+00:00

Random numbers are a very useful feature in many different types of programs, from mathematics and data analysis through to computer games and encryption applications. You may be surprised to learn that it’s actually quite difficult to get a computer to generate true randomness. However, if you’re careful, the NumPy random number generator can generate random enough numbers for everyday purposes.

Maybe you’ve already worked with randomly generated data in Python. While modules like random are great options for producing random scalars, using the numpy.random module will unlock even more possibilities for you.

In this tutorial, you’ll learn how to:

Generate NumPy arrays of random numbers
Randomize NumPy arrays
Randomly select parts of NumPy arrays
Take random samples from statistical distributions

Before starting this tutorial, you should understand the basics of NumPy arrays. With that knowledge, you’re ready to dive in.

Free Bonus: Click here to download the sample code that shows you how to get random numbers with NumPy.

Understanding the NumPy Pseudo-Random Number Generator

When you ask a computer to perform any task for you, it does so by following a set of instructions defined by an algorithm. When you need it to generate random numbers, the computer uses a pseudo-random number generator (PRNG) algorithm. There are several of these available, some of which are better than others.

To generate random numbers, Python uses the random module, which generates numbers using the Mersenne twister algorithm. While this is still widely used in Python code, it’s possible to predict the numbers that it generates, and it requires significant computing power.

Since version 1.17, NumPy uses the more efficient permuted congruential generator-64 (PCG64) algorithm. This produces less-predictable numbers, as shown by its performance in the industry-standard TestU01 statistical test. PCG64 is also faster and requires fewer resources to work.

Note: While the PCG64 algorithm is certainly an improvement on the Mersenne twister algorithm, it still has some statistical weaknesses. An updated version, PCG64DXSM, addresses these issues. This will become the default in future NumPy releases. On a practical level, you won’t notice any difference, but if you want to know more, see Upgrading PCG64 with PCG64DXSM in the NumPy documentation.

In most of the examples throughout this tutorial, you’ll use the default PCG64 algorithm, although you’ll also try your hand at using the updated PCG64DXSM algorithm.

If you’re interested in learning more about the different types of PRNG algorithms and how the PCG algorithms compare to others, then you should read PCG, A Family of Better Random Number Generators from the developer of PCG.

PRNGs are called pseudo-random because they’re not random! PRNGs are deterministic, which means they generate sequences of numbers that are reproducible. PRNGs require a seed number to initialize their number generation. PRNGs that use the same seed will generate the same numbers.

PRNGs also have a period property, which is the number of iterations they go through before they start repeating. Because the generated numbers depend on the seed, they’re not truly random but are instead pseudo-random.

Because seeds should be random, you need one random number to generate another. For this purpose, PRNGs use the computer hardware clock’s time as their default seed. This is measured to the nanosecond, so running number generators consecutively results in different seed values and therefore different sequences of random numbers. NumPy uses a hashing technique to ensure that the seed is 128 bits long, even if you only supply a 64-bit integer.

The period does mean that the same numbers could reappear. In practice, this isn’t a concern because the period lengths are huge. The period of PCG64, for example, is about 50 billion times the number of atoms that exist inside of you!

Note: If you want to learn more about how random randomly generated numbers actually are, take a look at the tutorial How Random is Random?

The core of NumPy’s number generation is the BitGenerator class. This class allows you to specify an algorithm and seed. To access the random numbers, the BitGenerator is passed into a separate Generator object. Generators have methods that allow you to access a range of random numbers and perform several randomizing operations. The numpy.random module provides this capability.

You may have noticed that the NumPy.random documentation also contains information about the RandomState class. This is a container class for the slower Mersenne twister PRNG. The more modern Generator class has now superseded RandomState, which you should no longer use in new code. However, RandomState is still around for existing legacy applications.

Before you go any further, be aware that the NumPy PRNGs are not suitable for cryptographic purposes. They’re only suitable for data analysis tasks. If you need random numbers for cryptographic purposes, then you need a cryptographically secure pseudo-random number generator (CSPRNG).

Generating Random Data With the NumPy Random Number Generator

Now that you understand a computer’s capabilities for generating random numbers, in this section, you’ll learn how to generate both floating-point numbers and integers randomly using NumPy. After generating individual numbers, you’ll learn how to generate NumPy arrays of random numbers.

Random Numbers

If you’re happy to let NumPy perform all of your random number generation work for you, you can use its default values. In other words, your BitGenerator will use PCG64 with a seed from the computer’s clock. To facilitate the defaults, NumPy provides a very handy default_rng() function. This sets everything up for you and returns a reference to a Generator object for you to use to produce random numbers using its range of powerful methods.

To begin with, this code generates a floating-point number using NumPy’s defaults:

>>>

>>> import numpy as np

>>> default_rng = np.random.default_rng()
>>> default_rng
'Generator(PCG64) at 0x1E9F2ABBF20'

>>> default_rng.random()
0.47418635476614734

Read the full article at https://realpython.com/numpy-random-number-generator/ »

[ 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 #158: Building Python CI With Docker & Applying for a Hacker Initiative Grant

2023-06-02T12:00:00+00:00

Do you need a refresher on using Docker with Python? Would you like to learn how to configure a continuous integration pipeline with modern tools and Docker? 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 ]

Create and Modify PDF Files in Python

2023-05-31T14:00:00+00:00

It’s really useful to know how to create and modify PDF (portable document format) files in Python. This is one of the most common formats for sharing documents over the Internet. PDF files can contain text, images, tables, forms, and rich media like videos and animations, all in a single file.

This abundance of content types can make working with PDFs difficult. There are several different kinds of data to decode when opening a PDF file! Fortunately, the Python ecosystem has some great packages for reading, manipulating, and creating PDF files.

In this tutorial, you’ll learn how to:

Read text from a PDF with pypdf
Split a PDF file into multiple files
Concatenate and merge PDF files together
Rotate and crop pages in PDF files
Encrypt and decrypt PDF files
Create and customize PDF files from scratch with ReportLab

To complete this learning, you’ll use two different tools. You’ll use the pypdf library to manipulate existing PDF files and the ReportLab library to create new PDF files from scratch. Along the way, you’ll have several opportunities to deepen your understanding with exercises and examples.

To follow along with this tutorial, you should download and extract to your home folder the materials used in the examples. To do this, click the link below:

Download the sample materials: Click here to get the materials you’ll use to learn about creating and modifying PDF files in this tutorial.

Extracting Text From PDF Files With `pypdf`

In this section, you’ll learn how to read PDF files and extract their text using the pypdf library. Before you can do that, though, you need to install it with pip:

$ python -m pip install pypdf

With this command, you download and install the latest version of pypdf from the Python package index (PyPI). To verify the installation, go ahead and run the following command in your terminal:

$ python -m pip show pypdf
Name: pypdf
Version: 3.8.1
Summary: A pure-python PDF library capable of splitting,
 merging, cropping, and transforming PDF files
Home-page:
Author:
Author-email: Mathieu Fenniak <biziqe@mathieu.fenniak.net>
License:
Location: .../lib/python3.10/site-packages
Requires:
Required-by:

Pay particular attention to the version information. At the time of publication for this tutorial, the latest version of pypdf was 3.8.1. This library has gotten plenty of updates lately, and cool new features are added quite frequently. Most importantly, you’ll find many breaking changes in the library’s API if you compare it with its predecessor library PyPDF2.

Before diving into working with PDF files, you must know that this tutorial is adapted from the chapter “Creating and Modifying PDF Files” in Python Basics: A Practical Introduction to Python 3.

The book uses Python’s built-in IDLE editor to create and edit Python files and interact with the Python shell, so you’ll find occasional references to IDLE throughout this tutorial. However, you should have no problems running the example code from the editor and environment of your choice.

Reading PDF Files With `PdfReader`

To kick things off, you’ll open a PDF file and read some information about it. You’ll use the Pride_and_Prejudice.pdf file provided in the downloadable resources for this tutorial.

Open IDLE’s interactive window and import the PdfReader class from pypdf:

>>>

>>> from pypdf import PdfReader

To create a new instance of the PdfReader class, you’ll need to provide the path to the PDF file that you want to open. You can do that using the pathlib module:

>>>

>>> from pathlib import Path

>>> pdf_path = (
...     Path.home()
...     / "creating-and-modifying-pdfs"
...     / "practice_files"
...     / "Pride_and_Prejudice.pdf"
... )

The pdf_path variable now contains the path to a PDF version of Jane Austen’s Pride and Prejudice.

Note: You may need to change pdf_path so that it corresponds to the location of the creating-and-modifying-pdfs/ folder on your computer.

Now create the PdfReader instance by calling the class’s constructor with the path to your PDF file as an argument:

>>>

>>> pdf_reader = PdfReader(pdf_path)

Read the full article at https://realpython.com/creating-modifying-pdf/ »

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

Getting the First Match From a Python List or Iterable

2023-05-30T14:00:00+00:00

At some point in your Python journey, you may need to find the first item that matches a certain criterion in a Python iterable, such as a list or dictionary.

The simplest case is that you need to confirm that a particular item exists in the iterable. For example, you want to find a name in a list of names or a substring inside a string. In these cases, you’re best off using the in operator. However, there are many use cases when you may want to look for items with specific properties. For instance, you may need to:

Find a non-zero value in a list of numbers
Find a name of a particular length in a list of strings
Find and modify a dictionary in a list of dictionaries based on a certain attribute

In this video course, you’ll explore how best to approach all three scenarios.

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

Choosing the Best Coding Font for Programming

2023-05-29T14:00:00+00:00

When you’re coding, there’s always a font involved in displaying the text on the screen. Yet, the font that you use is an often-overlooked piece in your programming tool kit. Many operating systems and code editors come with their default monospace fonts that you may end up using.

But there are a bunch of technicalities and features to take into consideration when choosing the best font for your daily programming. That’s why it’s worth investigating the requirements that a programming font should fulfill to make it a perfect match for you.

In this tutorial, you’ll learn:

How to spot a high-quality coding font
What characters are important when coding in Python
Which features of a programming font matter
Where to download programming fonts
How to install a font on your operating system

Throughout the tutorial, you’ll consider twenty-seven hand-picked programming fonts that you can use right away. You’ll take a close look at all the fonts and investigate why their particular features are important for you as a programmer. In the end, you’ll be able to decide which coding fonts suit your needs best.

If you want to keep a list of the fonts for future reference, then you can get an overview PDF of all the fonts by clicking the link below:

Free Bonus: Click here to download your comprehensive guide to all the coding fonts in this tutorial.

Say Hello to Your Next Coding Font

In this tutorial, you’ll take a deep dive and learn about the forms and shapes that make a quality coding font. You’ll encounter significant technical details, handy features, and surprising quirks along the way.

Note: In this tutorial, you’ll focus on the characteristics of fonts that are suitable for Python programming. But the fonts will work similarly in any other programming language.

You’ll notice that all the images in this tutorial have a similar style. The font name is always on the left. On the right, you’ll see a sample string or specific characters worth noting. To kick things off, have a look at the fonts that you’ll examine in this tutorial:

It’s a good idea to open this image in another window and keep it open while you read the tutorial. For example, you can right-click the image above, select Open Image in New Window, and then drag the tab into a new window:

Having the tutorial and the fonts list side by side lets you conveniently compare certain fonts with others. You can even go a step further and print the image to annotate the fonts with your likes and dislikes.

If you’re already excited to try out new fonts in your own coding editor, then you can scroll down to the get your new coding font section. There you can download all the fonts in this tutorial and load them up in your editor. That way, you can get a head start and evaluate any font with your own editor theme, preferred font size, and some familiar code.

Note: Color schemes and font sizes are very personal settings that can easily skew your evaluation of a font. That’s why you won’t see any larger code samples set in any font in this tutorial.

Instead, you’ll see many examples that objectively focus on specific font characteristics, independently of any coding editors.

Once you try out a coding font, you’ll recognize if you like or dislike it. Sometimes it’s just a matter of taste. But sometimes there are reasons why one font might be a better fit for you while another isn’t.

Over the next few sections, you’ll get a tool set so that you can evaluate for yourself what makes a quality programming font.

Consider the Basics

Whether you just wrote your first Hello, World! script or maintain huge codebases, choosing the right programming font will be beneficial for you as a developer.

Before you dig into the characteristics of a font on a character level, there are some broader features to take into consideration. Some of them may filter out a font in your search from the get-go.

For example, a font might not be a good choice if the font doesn’t support your language or if it costs money that you’re not willing to invest. Another criterion could be that the font must be monospace.

In this section, you’ll explore important points of comparison. That way, you’ll know which fonts to include in your circle of coding fonts to consider more closely.

Does the Font File Format Matter?

Read the full article at https://realpython.com/coding-font/ »

[ 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 #157: Discussing Mojo & Improving Python Object-Oriented Programming

2023-05-26T12:00:00+00:00

Would you like to speed up your Python machine-learning code dramatically? What if you only had to change a few keywords and add a couple of type hints on portions of your code? 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's .call() Method: Creating Callable Instances

2023-05-24T14:00:00+00:00

In Python, a callable is any object that you can call using a pair of parentheses and, optionally, a series of arguments. Functions, classes, and methods are all common examples of callables in Python. Besides these, you can also create custom classes that produce callable instances. To do this, you can add the .__call__() special method to your class.

Instances of a class with a .__call__() method behave like functions, providing a flexible and handy way to add functionality to your objects. Understanding how to create and use callable instances is a valuable skill for you as a Python developer.

In this tutorial, you’ll:

Understand the concept of callable objects in Python
Create callable instances by providing your classes with a .__call__() method
Understand the difference between .__init__() and .__call__()
Code several examples of using callable instances to solve real-world problems

To get the most out of this tutorial, you should be comfortable with the basics of object-oriented programming in Python, including how to define and use classes and methods. Some familiarity with Python decorators and the strategy design pattern will also help. You should also understand the concept of state.

Free Bonus: Click here to download your sample code so that you can create callable instances with Python’s .__call__() method.

Understanding Callable Objects in Python

A callable in Python is any object that you can call using a pair of parentheses and a series of arguments if required. You’ll find different examples of callables in your daily interaction with Python. Some of them include:

Built-in functions and classes
User-defined functions that you create with the def keyword
Anonymous functions that you write using the lambda keyword
The constructors of your custom classes
Instance, class, and static methods
Instances of classes that implement the .__call__() method
Closures that you return from your functions
Generator functions that you define using the yield keyword
Asynchronous functions and methods that you create with the async keyword

All these different callables have something in common. They all implement the .__call__() special method. To confirm this fact, you can use the built-in dir() function, which takes an object as an argument and returns the object’s list of attributes and methods:

>>>

>>> dir(abs)
[
    '__call__',
    '__class__',
    ...
]

>>> dir(all)
[
    '__call__',
    '__class__',
    ...
]

>>> def greet():
...     print("Hello, World!")
...

>>> dir(greet)
[
    '__annotations__',
    '__builtins__',
    '__call__',
    ...
]

In the first two examples, you call dir() with the built-in abs() and all() functions as arguments. In both cases, you can see that the .__call__() method is present in the output.

In the final example, you define a custom function that prints a message to the screen. This function also has .__call__(). Note how you can use this method to call the function:

>>>

>>> greet.__call__()
Hello, World!

Note that using .__call__() as you did in this example produces the same effect as calling the function directly with greet().

Note: Even though you can call special methods like .__call__() directly, doing so isn’t a recommended or best practice. Instead, call the functions as usual.

Now, how does all this work internally? When you run something like callable_object(*args, **kwargs), Python internally translates the operation into callable_object.__call__(*args, **kwargs). The arguments to the regular function are the same as those used in .__call__(). In other words, whenever you call a callable object, Python automatically runs its .__call__() method behind the scenes using the arguments you’ve passed into the callable.

Now take a look at the following custom class:

>>>

>>> class SampleClass:
...     def method(self):
...         print("You called method()!")
...

>>> type(SampleClass)
<class 'type'>

>>> dir(type)
[
    '__abstractmethods__',
    '__annotations__',
    '__base__',
    '__bases__',
    '__basicsize__',
    '__call__',
    ...
]

>>> sample_instance = SampleClass()
>>> dir(sample_instance.method)
[
    '__call__',
    '__class__',
    ...
]

In Python, everything is an object. Classes like SampleClass are objects of type, which you can confirm by calling type() with the class object as an argument or by accessing the .__class__ attribute.

The class constructor of SampleClass falls back to using type.__call__(). That’s why you can call SampleClass() to get a new instance. So, class constructors are callable objects that return new instances of the underlying class.

In the example above, you can observe that method objects, like sample_instance.method, also have a .__call__() special method that turns them into callable objects. The main takeaway here is that to be callable, an object needs to have a .__call__() method.

If you inspect a closure, generator function, or asynchronous function, then you’ll get similar results. You’ll always find a .__call__() method in callable objects.

Checking Whether an Object Is Callable

If you ever need to check whether a Python object is callable, then you can use the built-in callable() function like in the following examples:

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

[ 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 k-Nearest Neighbors (kNN) in Python

2023-05-23T14:00:00+00:00

In this video course, you’ll get a thorough introduction to the k-Nearest Neighbors (kNN) algorithm in Python. The kNN algorithm is one of the most famous machine learning algorithms and an absolute must-have in your machine learning toolbox. Python is the go-to programming language for machine learning, so what better way to discover kNN than with Python’s famous packages NumPy and scikit-learn!

You’ll explore the kNN algorithm both in theory and in practice. It’s important to learn about the mechanics of machine learning algorithms to understand their potential and limitations. At the same time, it’s essential to understand how to use an algorithm in practice. With that in mind, you’ll also focus on the use of kNN in the Python library scikit-learn.

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

Explain the kNN algorithm both intuitively and mathematically
Implement kNN in Python from scratch using NumPy
Use kNN in Python with scikit-learn

[ 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 Launch an HTTP Server in One Line of Python Code

2023-05-22T14:00:00+00:00

Traditionally, if you wanted to handle HTTP requests and serve static content from files, then you had to set up a full-fledged web server like Apache or NGINX, which could be a tedious process. Building a dynamic web application requires installing a web framework, such as Django, Flask, or FastAPI, which adds yet another complexity layer. Fortunately, you can take advantage of a basic HTTP server built into Python to avoid all this hassle.

Python’s HTTP server can come in handy when you want to quickly share a bunch of files with students in a classroom or anyone else who’s connected to the same network as you. Maybe you need to host static resources downloaded from the Internet for offline development of a PyScript application or spin up a local web server to experiment with the HTTP protocol in your terminal. You may also have a Python script that should be triggered remotely.

You can do all of this with a single command thanks to the http.server module that ships with the Python standard library!

Free Bonus: Click here to download the sample code that shows you how to write a one-liner Python HTTP server and more.

How to Start Python’s `http.server` in the Command Line

Open a command prompt or terminal window and navigate to the directory where you want to launch the HTTP server. Alternatively, on most modern operating systems, you can right-click a given folder and choose to open the terminal there. Once you’re in the correct place, type and run the following command:

$ python3 -m http.server
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Python starts an HTTP server on port 8000 and binds it to all the available network interfaces on your machine, which are denoted with a special IP address. Depending on your operating system’s preference, the underlying socket library may choose to bind to IPv4 address 0.0.0.0 or IPv6 address ::. Either way, anyone on your network can use your computer’s IP address to access the HTTP server that you just started.

Note: To find your local IP address, you can check your network settings or, depending on your operating system, use one of the commands below:

macOS: ifconfig
Windows: ipconfig
Linux: ip address or hostname -I

Visiting a website like ifconfig.me will reveal your public IP address, which is typically the address of your router. It’s most likely different from the local address of the device that you’re using. Unless you’ve configured port forwarding in your router, the HTTP server won’t be accessible from the Internet through your public address.

If the default port number, 8000, is unavailable, then you’ll see the following error when you make an attempt to start the server:

$ python3 -m http.server
Traceback (most recent call last):
  ...
OSError: [Errno 98] Address already in use

This means that another program is currently occupying that port. To fix this problem, you can find the offending program and forcefully stop it. However, because that may not always be desirable, you can also assign a different port to your server. To explicitly set the port number that your HTTP server should be listening on, append it as a parameter:

$ python3 -m http.server 8080
Serving HTTP on 0.0.0.0 port 8080 (http://0.0.0.0:8080/) ...

Sometimes, it takes trial and error to find a free port, especially when many services are running in the background while listening for network traffic on different ports. Remember that a given port can belong to at most one program at a time, but the same program can own multiple ports simultaneously. Usually, each port is associated with a different service.

Note: Web browsers automatically use port 80 to communicate with web servers over the HTTP protocol, even when you don’t explicitly specify the port number in the address bar. For example, these two addresses are equivalent:

http://localhost:80
http://localhost

Port 80 is a standard port reserved for HTTP traffic. However, if you’d like to start a local web server on that special port, then you’ll have to run the corresponding command as the superuser with administrative privileges. Otherwise, you’ll get another error:

$ python3 -m http.server 80
Traceback (most recent call last):
  ...
PermissionError: [Errno 13] Permission denied

All port numbers below 1024 require administrative privileges. You can prefix a command with sudo to run it as the root user on macOS and Linux. On the other hand, to run a similar command with elevated privileges on Windows, you must first open the terminal as an administrator.

For security reasons, you may restrict access to your HTTP server by running it on an address belonging to the virtual loopback interface or localhost, which no one except you will be able to speak to. You can bind a specific network interface or IP address by using the -b option:

$ python3 -m http.server -b 127.0.0.42 8080
Serving HTTP on 127.0.0.42 port 8080 (http://127.0.0.42:8080/) ...

In this case, you combine the -b option, which binds a specific address on the loopback interface, with a positional argument determining the port number. These parameters ensure that your server will only be accessible from the local machine.

Note: When you rely on the defaults, Python will bind to a network address family that your operating system prefers. To enforce a different address, you can use the -b option:

$ python -m http.server -b "::"
Serving HTTP on :: port 8000 (http://[::]:8000/) ...

The double colon (::) is a shorthand notation for IPv6 unspecified address. In most cases, binding to an IPv6 address will enable dual-stack IP mode, letting you connect to the server through both IPv4 and IPv6 addresses. However, it doesn’t work the other way around, so binding to an IPv4 address won’t allow you to connect to the server through an IPv6 address.

By default, Python serves the files located in your current working directory where you executed the command to start the server. So, when you visit the home address (/) of your server in a web browser, then you’ll see all the files and folders in the corresponding directory:

Here, you see the content of your home directory, which is where the server must’ve been started in the command line. Clicking one of the displayed links will send another request to the server, letting you navigate the directory tree in the browser.

You may instruct the server to associate its home address (/) with a completely different directory by specifying the optional -d parameter:

$ python3 -m http.server -d ~/Pictures/
Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...

Now, the server will list the pictures in one of your home directory’s subfolders. Your shell expands the tilde character (~) into the home directory of the current user. Note that you can use both relative and absolute paths to indicate a directory to serve over HTTP.

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

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

ChatGPT: Your Personal Python Coding Mentor

2023-05-17T14:00:00+00:00

Large language models (LLMs) have quickly gained popularity since OpenAI released ChatGPT for public access. Since then, people have used ChatGPT for fun, creative, and useful purposes. If you’ve dreamed about using ChatGPT as your Python coding mentor, then keep on reading.

Using ChatGPT as your mentor doesn’t mean that you should try to build a software solution without knowing anything about programming. Instead, you’ll focus on using ChatGPT as a learning tool. It probably can’t replace you as a programmer, but it can help you to improve your code and learn in the process.

In this tutorial, you’ll learn how to:

Set up ChatGPT for use
Debug your code using ChatGPT
Improve your code style and code quality
Pair program with ChatGPT
Explore alternative implementations of a code snippet
Get answers to your programming questions

You’ll also get to see examples of how ChatGPT can produce incorrect and irrelevant solutions, and you’ll learn how you can improve its responses by working on better prompts. In the downloadable materials, you get access to all the code snippets in the tutorial, as well as all the prompts that you’ll use to interact with ChatGPT:

Free Bonus: Click here to download the free sample code and engineered prompts that show you how to boost your Python programming skills with the help of ChatGPT.

Set Up Your ChatGPT Coding Mentor

To access ChatGPT, you only need to create an account with OpenAI. When you first head to chat.openai.com, then you’ll be prompted to either sign in or sign up:

If you’ve already played with ChatGPT before and have an active account, then sign in and skip to the next section. Otherwise, continue reading for a quick walk-through on signing up for the service.

If you don’t have an account with OpenAI yet, then click on Sign up. You’ll be redirected to a page that allows you to sign up using your Google or Microsoft account or a personal email address:

If you choose to sign up using your email address, then you’ll need to enter a password next. Choose a strong password and complete the sign-up process.

You’ll then be redirected to the main page of ChatGPT, where you’ll get to interact with the large language model through a conversational interface where you enter questions, and the chat provides answers:

In the future, you can navigate to chat.openai.com to directly access this page since you’ve completed the sign-up process. Every so often, after your browser session expires, you’ll have to log in again.

Beware of Incorrect and Irrelevant Information

Now that you’ve signed up for ChatGPT, you probably want to give it a spin! But before you hit the throttle, it’s important to know what kinds of issues you might run into. While large language models offer several new possibilities for enhancing your studies, you need to remember the potentially negative effects of using ChatGPT as your coding mentor:

Overreliance: Leaning too heavily on ChatGPT for answers can hinder your own learning. You build brain paths by thinking, struggling, checking your understanding, and memorizing information.
Accuracy: ChatGPT’s responses may often be inaccurate or irrelevant. You need to fact-check all of its answers! Otherwise, you might learn wrong concepts and bad practices.

In this section and throughout the tutorial, you’ll encounter a few examples of incorrect and irrelevant answers. Hopefully, these examples will help you keep in mind that even if ChatGPT’s responses seem logical at first sight, they’re not always correct. Sometimes the errors in a response are so subtle that you’ll spot them only if you’re an expert programmer.

In a classic workflow with ChatGPT, you ask a question in the chat interface, and the underlying language model, GPT-3.5, will create a reply that you’ll see pop up as a chat response. ChatGPT will even format the replies in useful ways. For example, go ahead and ask the chat to generate some useful Python learning material for you:

You: Please show me a table with a cheat sheet of Python’s syntax.

When you ask ChatGPT for a table, then it’ll create Markdown that the chat interface knows to display beautifully. As for the content of that cheat sheet, it’ll pick some of Python’s syntax, and the results might be correct and relevant:

The table that you’ll receive as output will most likely be different. It could be quite similar, but it doesn’t have to be. The LLM behind ChatGPT will always create a new response, predicting the most likely next piece of information based on its training. But the output isn’t deterministic, and it’s often even incorrect.

Read the full article at https://realpython.com/chatgpt-coding-mentor-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 ]

Metaclasses in Python

2023-05-16T14:00:00+00:00

In Python, everything is an object, even the classes that create objects. You used a class to instantiate an object instance, but classes themselves are also instantiated behind the scenes. This mechanism is available to you as a programmer through the concept of metaclasses.

Metaclasses allow you to hook when classes are created, and this technique is what’s behind magical frameworks like Django and SQLAlchemy where class definitions have side effects that impact databases.

In this course you’ll learn about how:

Everything really is an object, including classes themselves
The type() function works
Classes instantiate objects and get instantiated themselves
You can hook class instantiation with the metaclass argument

Metaclasses aren’t for the faint of heart, but they do allow you to do some magic. Plus, learning about them can help you understand what exactly happens behind the scenes when you instantiate a class.

[ 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 #156: Virtual Environment Structure & Surveying the Packaging Ecosystem

2023-05-12T12:00:00+00:00

How do Python virtual environments work under the hood? How does understanding these concepts help you with managing them for your projects? This week on the show, CPython core developer Brett Cannon returns to discuss his recent articles about virtual environments and the Python packaging landscape.

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

Getting the Most Out of the Python Standard REPL

2023-05-09T14:00:00+00:00

The Python standard shell, or REPL (Read-Eval-Print Loop), allows you to run Python code interactively while working on a project or learning the language. This tool is available in every Python installation, so you can use it at any moment.

As a Python developer, you’ll spend a considerable part of your coding time in a REPL session because this tool allows you to test new ideas, explore and experiment with new tools and libraries, refactor and debug your code, and try out examples.

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

Run the Python standard REPL, or interactive shell
Write and execute Python code in an interactive session
Quickly edit, modify, and reuse code in a REPL session
Get help and introspect your code in an interactive session
Tweak some features of the standard REPL
Identify the standard REPL’s missing features

You’ll also learn about available feature-rich REPLs, such as IDLE, IPython, bpython, and ptpython.

To get the most out of this video course, you should be familiar with your operating system’s command line, or terminal. You should also know the basics of using the python command to run your code.

[ 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 #155: Checking Project Dependencies & Python Dev Resource Collections

2023-05-05T12:00:00+00:00

How can you ensure that you've appropriately declared your project's required dependencies? How do you determine what dependencies are missing from a third-party project that you can't run? 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 ]

Publishing Python Packages to PyPI

2023-05-02T14:00:00+00:00

PyPI is the public hosting service where open-source Python packages live. When you pip install a package, that’s where it fetches it from. In this course, you’ll learn all about the structures of a package and how to upload your own to the PyPI server.

In this video course, you’ll learn about:

Why packages and virtual environments exist
How to structure a package
How to use build systems
The contents of the pyproject.toml file
How to use the build and twine tools
What the Flit and Poetry tools offer

Throughout this course, you’ll work with an example project: a reader package that can be used to read Real Python tutorials in your console.

[ 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 #154: Targeting WebAssembly Platforms & Distilling a Minimum Viable Python

2023-04-28T12:00:00+00:00

Are you familiar with the different versions of WebAssembly? Could WASM be the "write once, run everywhere" solution that developers have searched for? Where does distributing Python applications fit in the narrative? This week on the show, we have CPython core developer Brett Cannon to discuss his recent articles about WebAssembly and MVPy.

[ 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 Python's assert to Debug and Test Your Code

2023-04-25T14:00:00+00:00

Python’s assert statement allows you to write sanity checks in your code. These checks are known as assertions, and you can use them to test if certain assumptions remain true while you’re developing your code. If any of your assertions turn false, then you have a bug in your code.

Assertions are a convenient tool for documenting, debugging, and testing code during development. Once you’ve debugged and tested your code with the help of assertions, then you can turn them off to optimize the code for production. Assertions will help you make your code more efficient, robust, and reliable.

In this video course, you’ll learn:

What assertions are and when to use them
How Python’s assert statement works
How assert can help you document, debug, and test your code
How assertions can be disabled to improve performance in production
What common pitfalls you might face when using assert statements

To get the most out of this video course, you should have previous knowledge of expressions and operators, functions, conditional statements, and exceptions. Having a basic understanding of documenting, debugging, and testing Python code is also a plus.

[ 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: Installing Packages With pip

2023-04-18T14:00:00+00:00

So far on the Python Basics learning path, you’ve been working within the bounds of the Python standard library. Now it’s time to unlock packages that aren’t included with Python by default. To do that, you’ll need pip.

Many programming languages offer a package manager that automates the process of installing, upgrading, and removing third-party packages. Python is no exception. The de facto package manager for Python is called pip.

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

Install and manage third-party packages with pip
Use virtual environments to separate project dependencies
Declare requirements and re-create a development environment
Navigate PyPI, the Python Package Index

With that knowledge as your guide, you’ll be able to confidently install packages to suit your programming needs.

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.

[ 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 #153: Seeking Faster Text Processing & Python's .repr() vs .str()

2023-04-14T12:00:00+00:00

What can you do if your text manipulation in Python is slowing you down? Are there faster alternatives using a compiled extension? 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 ]

Using OrderedDict in Python

2023-04-11T14:00:00+00:00

Sometimes you need a Python dictionary that remembers the order of its items. In the past, you had only one tool for solving this specific problem: Python’s OrderedDict. It’s a dictionary subclass specially designed to remember the order of items, which is defined by the insertion order of keys.

This changed in Python 3.6. The built-in dict class now keeps its items ordered as well. Because of that, many in the Python community now wonder if OrderedDict is still useful. A closer look at OrderedDict will uncover that this class still provides valuable features.

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

Create and use OrderedDict objects in your code
Identify the differences between OrderedDict and dict
Understand the pros and cons of using OrderedDict vs dict

With this knowledge, you’ll able to choose the dictionary class that best fits your needs when you want to preserve the order of items.

By the end of the course, you’ll see an example of implementing a dictionary-based queue using OrderedDict, which would be more challenging if you used a regular dict object.

[ 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 #152: Automate Processes and Distribute Python Tools With RPA and RCC

2023-04-07T12:00:00+00:00

Are you exploring automation of your repetitive business tasks with Python? How are you going to share your helpful tools with co-workers? This week on the show, Sampo Ahokas from Robocorp is here to discuss robotic process automation (RPA) and distribution of these robots.

[ 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 #151: Evaluating Python Packages & Celebrating 20 Years of PyCon US

2023-03-31T12:00:00+00:00

Have you ever installed a Python package without knowing anything about it? What best practices should you employ to ensure the quality of your next package installation? Christopher Trudeau is back this week, bringing another batch of PyCoder's Weekly articles and projects. We also have Python Software Foundation executive director, Deb Nicholson, to share details about PyCon US 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 ]

Real Python

Python's raise: Effectively Raising Exceptions in Your Code

Handling Exceptional Situations in Python

Raising Exceptions in Python: The raise Statement

The Real Python Podcast – Episode #160: Inheriting a Large Python Code Base & Building a GUI With Kivy

How to Make Engaging Programming Videos

Decide When a Programming Video Makes Sense

Focus on the Outcome

Sketch Out Code Examples

Take Speaker Notes

Python Basics: Reading and Writing Files

Python News: What's New From May 2023

Python 3.12 in Beta

The Real Python Podcast – Episode #159: Volunteering, Organizing, and Finding a Python Community

What's the Zen of Python?

In Short: It’s a Humorous Poem Listing Python Philosophies

How Did the Zen of Python Originate?

Should You Obey the Zen of Python?

Mazes in Python Part 1: Building and Visualizing

Using the NumPy Random Number Generator

Understanding the NumPy Pseudo-Random Number Generator

Generating Random Data With the NumPy Random Number Generator

Random Numbers

The Real Python Podcast – Episode #158: Building Python CI With Docker & Applying for a Hacker Initiative Grant

Create and Modify PDF Files in Python

Extracting Text From PDF Files With pypdf

Reading PDF Files With PdfReader

Getting the First Match From a Python List or Iterable

Choosing the Best Coding Font for Programming

Say Hello to Your Next Coding Font

Consider the Basics

Does the Font File Format Matter?

The Real Python Podcast – Episode #157: Discussing Mojo & Improving Python Object-Oriented Programming

Python's .__call__() Method: Creating Callable Instances

Understanding Callable Objects in Python

Checking Whether an Object Is Callable

Using k-Nearest Neighbors (kNN) in Python

How to Launch an HTTP Server in One Line of Python Code

How to Start Python’s http.server in the Command Line

ChatGPT: Your Personal Python Coding Mentor

Set Up Your ChatGPT Coding Mentor

Beware of Incorrect and Irrelevant Information

Metaclasses in Python

The Real Python Podcast – Episode #156: Virtual Environment Structure & Surveying the Packaging Ecosystem

Getting the Most Out of the Python Standard REPL

The Real Python Podcast – Episode #155: Checking Project Dependencies & Python Dev Resource Collections

Publishing Python Packages to PyPI

The Real Python Podcast – Episode #154: Targeting WebAssembly Platforms & Distilling a Minimum Viable Python

Using Python's assert to Debug and Test Your Code

Python Basics: Installing Packages With pip

The Real Python Podcast – Episode #153: Seeking Faster Text Processing & Python's .__repr__() vs .__str__()

Using OrderedDict in Python

The Real Python Podcast – Episode #152: Automate Processes and Distribute Python Tools With RPA and RCC

The Real Python Podcast – Episode #151: Evaluating Python Packages & Celebrating 20 Years of PyCon US

Raising Exceptions in Python: The `raise` Statement

Extracting Text From PDF Files With `pypdf`

Reading PDF Files With `PdfReader`

Python's .call() Method: Creating Callable Instances

How to Start Python’s `http.server` in the Command Line

The Real Python Podcast – Episode #153: Seeking Faster Text Processing & Python's .repr() vs .str()