Real Python

Python 3.11: Cool New Features for You to Try

2022-10-24T14:00:00+00:00

Python 3.11 was published on October 24, 2022. This latest version of Python is faster and more user-friendly. After seventeen months of development, it’s now ready for prime-time use.

As in every version, Python 3.11 comes with lots of improvements and changes. You can see a list of all of them in the documentation. Here, you’ll explore the coolest and most impactful new features.

In this tutorial, you’ll learn about new features and improvements like:

Better error messages with more informative tracebacks
Faster code execution due to considerable effort in the Faster CPython project
Task and exception groups that simplify working with asynchronous code
Several new typing features that improve Python’s static typing support
Native TOML support for working with configuration files

If you want to try any of the examples in this tutorial, then you’ll need to use Python 3.11. The Python 3 Installation & Setup Guide and How Can You Install a Pre-Release Version of Python? walk you through several options for adding a new version of Python to your system.

In addition to learning more about the new features coming to the language, you’ll also get some advice about what to consider before upgrading to the new version. Click the link below to download code examples demonstrating the new capabilities of Python 3.11:

Free Download: Click here to download free sample code that demonstrates some of the new features of Python 3.11.

More Informative Error Tracebacks

Python is often recognized as a good beginner programming language, with its readable syntax and powerful data structures. A challenge for all, but especially those new to Python, is how to interpret the traceback that’s displayed when Python encounters an error.

In Python 3.10, Python’s error messages were greatly improved. Similarly, one of Python 3.11’s most anticipated features will also boost your developer experience. Decorative annotations are added to the tracebacks and can help you more quickly interpret an error message.

To see a quick example of the enhanced traceback, add the following code to a file named inverse.py:

# inverse.py

def inverse(number):
    return 1 / number

print(inverse(0))

You can use inverse() to calculate the multiplicative inverse of a number. There’s no multiplicative inverse of 0, so your code raises an error when you run it:

$ python inverse.py
Traceback (most recent call last):
  File "/home/realpython/inverse.py", line 6, in <module>
    print(inverse(0))
          ^^^^^^^^^^
  File "/home/realpython/inverse.py", line 4, in inverse
    return 1 / number
           ~~^~~~~~~~
ZeroDivisionError: division by zero

Note the ^ and ~ symbols embedded within the traceback. They’re used to guide your attention to the code that’s causing the error. As usual with tracebacks, you should start at the bottom and work your way up. In this example, a ZeroDivisionError is caused by the division 1 / number. The actual culprit is calling inverse(0), as 0 has no inverse.

Getting this extra help in spotting mistakes is useful. However, the annotated tracebacks are even more powerful if your code is more complex. They may be able to convey information that you couldn’t get from the traceback by itself before.

To appreciate the power of the improved tracebacks, you’ll build a small parser of information about a few programmers. Assume you have a file named programmers.json with the following content:

[
    {"name": {"first": "Uncle Barry"}},
    {
        "name": {"first": "Ada", "last": "Lovelace"},
        "birth": {"year": 1815},
        "death": {"month": 11, "day": 27}
    },
    {
        "name": {"first": "Grace", "last": "Hopper"},
        "birth": {"year": 1906, "month": 12, "day": 9},
        "death": {"year": 1992, "month": 1, "day": 1}
    },
    {
        "name": {"first": "Ole-Johan", "last": "Dahl"},
        "birth": {"year": 1931, "month": 10, "day": 12},
        "death": {"year": 2002, "month": 6, "day": 29}
    },
    {
        "name": {"first": "Guido", "last": "Van Rossum"},
        "birth": {"year": 1956, "month": 1, "day": 31},
        "death": null
    }
]

Note that the information about the programmers is quite inconsistent. While the information about Grace Hopper and Ole-Johan Dahl is complete, you’re missing Ada Lovelace’s day and month of birth as well as her year of death. Naturally, you only have birth information about Guido van Rossum. To top it off, you’ve only recorded Uncle Barry’s first name.

You’ll create a class that can wrap this information. Start by reading the information from the JSON file:

# programmers.py

import json
import pathlib

programmers = json.loads(
    pathlib.Path("programmers.json").read_text(encoding="utf-8")
)

You use pathlib to read the JSON file and json to parse the information into a Python list of dictionaries.

Next, you’ll use a data class to encapsulate the information about each programmer:

# programmers.py

from dataclasses import dataclass

# ...

@dataclass
class Person:
    name: str
    life_span: tuple[int, int]

    @classmethod
    def from_dict(cls, info):
        return cls(
            name=f"{info['name']['first']} {info['name']['last']}",
            life_span=(info["birth"]["year"], info["death"]["year"]),
        )

Each Person will have a name and a life_span attribute. Additionally, you add a convenience constructor that can initialize Person based on the information and structure in your JSON file.

Read the full article at https://realpython.com/python311-new-features/ »

[ 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 #130: Fostering an Internal Python Community & Managing the 3.11 Release

2022-10-21T12:00:00+00:00

Does your company have a plan for growing an internal Python community? What are the attributes to look for when bringing someone into your department? This week on the show, Pablo Galindo Salgado returns to talk about building community through the Python Guild at Bloomberg and managing the release of Python 3.11.

[ 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 Tic-Tac-Toe Game Engine With an AI Player in Python

2022-10-19T14:00:00+00:00

When you’re a child, you learn to play tic-tac-toe, which some people know as naughts and crosses. The game remains fun and challenging until you enter your teenage years. Then, you learn to program and discover the joy of coding a virtual version of this two-player game. As an adult, you may still appreciate the simplicity of the game by using Python to create an opponent with artificial intelligence (AI).

By completing this detailed step-by-step adventure, you’ll build an extensible game engine with an unbeatable computer player that uses the minimax algorithm to play tic-tac-toe. Along the way, you’ll dive into immutable class design, generic plug-in architecture, and modern Python code practices and patterns.

In this tutorial, you’ll learn how to:

Create a reusable Python library with the tic-tac-toe game engine
Model the domain of tic-tac-toe following Pythonic code style
Implement artificial players including one based on the minimax algorithm
Build a text-based console front end for the game with a human player
Explore strategies for performance optimizations

Click the link below to download the complete source code for this project:

Source Code: Click here to download the free source code that you’ll use to build a tic-tac-toe game engine and AI player with Python.

Demo: Tic-Tac-Toe AI Player in Python

By the end of this tutorial, you’ll have a highly reusable and extensible Python library with an abstract game engine for tic-tac-toe. It’ll encapsulate universal game rules and computer players, including one that never loses due to bare-bones artificial intelligence support. In addition, you’ll create a sample console front end that builds on top of your library and implements a text-based interactive tic-tac-toe game running in the terminal.

Here’s what actual gameplay between two players might look like:

Console Front End

Generally, you may mix and choose the players from among a human player, a dummy computer player making moves at random, and a smart computer player sticking to the optimal strategy. You can also specify which player should make the first move, increasing their chances of winning or tying.

Later, you’ll be able to adapt your generic tic-tac-toe library for different platforms, such as a windowed desktop environment or a web browser. While you’ll only follow instructions on building a console application in this tutorial, you can find Tkinter and PyScript front end examples in the supporting materials.

Note: These front ends aren’t covered here because implementing them requires considerable familiarity with threading, asyncio, and queues in Python, which is beyond the scope of this tutorial. But feel free to study and play around with the sample code on your own.

The Tkinter front end is a streamlined version of the same game that’s described in a separate tutorial, which only serves as a demonstration of the library in a desktop environment:

Tkinter Front End

Unlike the original, it doesn’t look as slick, nor does it allow you to restart the game easily. However, it adds the option to play against the computer or another human player if you want to.

The PyScript front end lets you or your friends play the game in a web browser even when they don’t have Python installed on their computer, which is a notable benefit:

PyScript Front End

If you’re adventurous and know a little bit of PyScript or JavaScript, then you could extend this front end by adding the ability to play online with another human player through the network. To facilitate the communication, you’d need to implement a remote web server using the WebSocket protocol, for instance. Take a look at a working WebSocket client and server example in another tutorial to get an idea of how that might work.

It’s worth noting that each of the three front ends demonstrated in this section merely implement a different presentation layer for the same Python library, which provides the underlying game logic and players. There’s no unnecessary redundancy or code duplication across them, thanks to the clear separation of concerns and other programming principles that you’ll practice in this tutorial.

Project Overview

The project that you’re going to build consists of two high-level components depicted in the diagram below:

The first component is an abstract tic-tac-toe Python library, which remains agnostic about the possible ways of presenting the game to the user in a graphical form. Instead, it contains the core logic of the game and two artificial players. However, the library can’t stand on its own, so you’re also going to create a sample front end to collect user input from the keyboard and visualize the game in the console using plain text.

You’ll start by implementing the low-level details of the tic-tac-toe library, and then you’ll use those to implement a higher-level game front end in a bottom-up fashion. When you finish this tutorial, the complete file structure resulting will look like this:

Read the full article at https://realpython.com/tic-tac-toe-ai-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 ]

Python Basics: Numbers and Math

2022-10-18T14:00:00+00:00

You don’t need to be a math whiz to program well. The truth is, few programmers need to know more than basic algebra.

Of course, how much math you need to know depends on the application you’re working on. In general, the level of math required to be a programmer is lower than you might expect.

Although math and computer programming aren’t as correlated as some people might believe, numbers are an integral part of any programming language, and Python is no exception.

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

Create integers and floating-point numbers
Use arithmetic expressions, math functions, and number methods
Format and display numbers in strings
Create complex numbers

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 ]

A Practical Introduction to Web Scraping in Python

2022-10-17T14:00:00+00:00

Web scraping is the process of collecting and parsing raw data from the Web, and the Python community has come up with some pretty powerful web scraping tools.

The Internet hosts perhaps the greatest source of information on the planet. Many disciplines, such as data science, business intelligence, and investigative reporting, can benefit enormously from collecting and analyzing data from websites.

In this tutorial, you’ll learn how to:

Parse website data using string methods and regular expressions
Parse website data using an HTML parser
Interact with forms and other website components

Note: This tutorial is adapted from the chapter “Interacting With the Web” 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 see 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.

Source Code: Click here to download the free source code that you’ll use to collect and parse data from the Web.

Scrape and Parse Text From Websites

Collecting data from websites using an automated process is known as web scraping. Some websites explicitly forbid users from scraping their data with automated tools like the ones that you’ll create in this tutorial. Websites do this for two possible reasons:

The site has a good reason to protect its data. For instance, Google Maps doesn’t let you request too many results too quickly.
Making many repeated requests to a website’s server may use up bandwidth, slowing down the website for other users and potentially overloading the server such that the website stops responding entirely.

Before using your Python skills for web scraping, you should always check your target website’s acceptable use policy to see if accessing the website with automated tools is a violation of its terms of use. Legally, web scraping against the wishes of a website is very much a gray area.

Important: Please be aware that the following techniques may be illegal when used on websites that prohibit web scraping.

For this tutorial, you’ll use a page that’s hosted on Real Python’s server. The page that you’ll access has been set up for use with this tutorial.

Now that you’ve read the disclaimer, you can get to the fun stuff. In the next section, you’ll start grabbing all the HTML code from a single web page.

Build Your First Web Scraper

One useful package for web scraping that you can find in Python’s standard library is urllib, which contains tools for working with URLs. In particular, the urllib.request module contains a function called urlopen() that you can use to open a URL within a program.

In IDLE’s interactive window, type the following to import urlopen():

>>>

>>> from urllib.request import urlopen

The web page that you’ll open is at the following URL:

>>>

>>> url = "http://olympus.realpython.org/profiles/aphrodite"

To open the web page, pass url to urlopen():

>>>

>>> page = urlopen(url)

urlopen() returns an HTTPResponse object:

>>>

>>> page
<http.client.HTTPResponse object at 0x105fef820>

To extract the HTML from the page, first use the HTTPResponse object’s .read() method, which returns a sequence of bytes. Then use .decode() to decode the bytes to a string using UTF-8:

>>>

>>> html_bytes = page.read()
>>> html = html_bytes.decode("utf-8")

Read the full article at https://realpython.com/python-web-scraping-practical-introduction/ »

[ 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 #129: Using an Ellipsis in Python & Goals for CPython 3.12

2022-10-14T12:00:00+00:00

Where should you use an ellipsis in Python? How does it behave as a placeholder in a script, project, or stub file? What are the next goals for the Faster CPython 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 ]

ChatterBot: Build a Chatbot With Python

2022-10-12T14:00:00+00:00

Chatbots can provide real-time customer support and are therefore a valuable asset in many industries. When you understand the basics of the ChatterBot library, you can build and train a self-learning chatbot with just a few lines of Python code.

You’ll get the basic chatbot up and running right away in step one, but the most interesting part is the learning phase, when you get to train your chatbot. The quality and preparation of your training data will make a big difference in your chatbot’s performance.

To simulate a real-world process that you might go through to create an industry-relevant chatbot, you’ll learn how to customize the chatbot’s responses. You’ll do this by preparing WhatsApp chat data to train the chatbot. You can apply a similar process to train your bot from different conversational data in any domain-specific topic.

In this tutorial, you’ll learn how to:

Build a command-line chatbot with ChatterBot
Train the chatbot to customize its responses
Export your WhatsApp chat history
Perform data cleaning on the chat export using regular expressions
Retrain the chatbot with industry-specific data

You’ll also learn how ChatterBot stores your training data, and you’ll find suggestions and pointers for next steps, so you can start collecting real user data and let the chatbot learn from it.

Overall, in this tutorial, you’ll quickly run through the basics of creating a chatbot with ChatterBot and learn how Python allows you to get fun and useful results without needing to write a lot of code.

Source Code: Click here to download the free source code that you’ll use to build a chatbot.

Demo

At the end of this tutorial, you’ll have a command-line chatbot that can respond to your inputs with semi-meaningful replies:

You’ll achieve that by preparing WhatsApp chat data and using it to train the chatbot. Beyond learning from your automated training, the chatbot will improve over time as it gets more exposure to questions and replies from user interactions.

Project Overview

The ChatterBot library combines language corpora, text processing, machine learning algorithms, and data storage and retrieval to allow you to build flexible chatbots.

You can build an industry-specific chatbot by training it with relevant data. Additionally, the chatbot will remember user responses and continue building its internal graph structure to improve the responses that it can give.

Attention: While ChatterBot is still a popular open source solution for building a chatbot in Python, it hasn’t been actively maintained for a while and has therefore accumulated a significant number of issues.

There are multiple forks of the project that implement fixes and updates to the existing codebase, but you’ll have to personally pick the fork that implements the solution you’re looking for and then install it directly from GitHub. A fork might also come with additional installation instructions.

To get started, however, you won’t use a fork. Instead, you’ll use a specific pinned version of the library, as distributed on PyPI. You’ll find more information about installing ChatterBot in step one.

In this tutorial, you’ll start with an untrained chatbot that’ll showcase how quickly you can create an interactive chatbot using Python’s ChatterBot. You’ll also notice how small the vocabulary of an untrained chatbot is.

Next, you’ll learn how you can train such a chatbot and check on the slightly improved results. The more plentiful and high-quality your training data is, the better your chatbot’s responses will be.

Therefore, you’ll either fetch the conversation history of one of your WhatsApp chats or use the provided chat.txt file that you can download here:

Source Code: Click here to download the free source code that you’ll use to build a chatbot.

It’s rare that input data comes exactly in the form that you need it, so you’ll clean the chat export data to get it into a useful input format. This process will show you some tools you can use for data cleaning, which may help you prepare other input data to feed to your chatbot.

After data cleaning, you’ll retrain your chatbot and give it another spin to experience the improved performance.

When you work through this process from start to finish, you’ll get a good idea of how you can build and train a Python chatbot with the ChatterBot library so that it can provide an interactive experience with relevant replies.

Prerequisites

Before you get started, make sure that you have a Python version available that works for this ChatterBot project. What version of Python you need depends on your operating system:

Read the full article at https://realpython.com/build-a-chatbot-python-chatterbot/ »

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

Providing Multiple Constructors in Your Python Classes

2022-10-11T14:00:00+00:00

Sometimes you need to write a Python class that provides multiple ways to construct objects. In other words, you want a class that implements multiple constructors. This kind of class comes in handy when you need to create instances using different types or numbers of arguments. Having the tools to provide multiple constructors will help you write flexible classes that can adapt to changing needs.

Python offers several techniques and tools that you can use to construct classes, including simulating multiple constructors through optional arguments, customizing instance creation via class methods, and doing special dispatch with decorators. If you want to learn about these techniques and tools, then this video course is for you.

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

Use optional arguments and type checking to simulate multiple constructors
Write multiple constructors using the built-in @classmethod decorator
Overload your class constructors using the @singledispatchmethod decorator

You’ll also get a peek under the hood at how Python internally constructs instances of a regular class and how some standard-library classes provide multiple constructors.

To get the most out of this video course, you should have basic knowledge of object-oriented programming and understand how to define class methods with @classmethod. You should also have experience working with decorators in Python.

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

Python News: What's New From September 2022?

2022-10-10T14:00:00+00:00

In September 2022, the Python 3.11.0rc2 release candidate version became available for you to test and stay on top of Python’s latest features. This release is the last preview version before the final release of Python 3.11.0, which is scheduled for October 24, 2022.

Python’s latest bugfix versions, including 3.10.7, have introduced breaking changes to cope with a security vulnerability that affects the str to int conversion and can leave you open to DDoS attacks.

As usual, the Python ecosystem has celebrated the release of new versions of many fundamental packages, libraries, and frameworks.

Let’s dive into the most exciting 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.

Python 3.11.0rc2 Was Released

Every month, Python releases several versions from its different development branches. New releases typically add new features, fix bugs, correct security vulnerabilities, and more. September 2022 brought several new releases for Python programmers to test, use, and enjoy. Most notable was Python’s last 3.11 release candidate.

Python 3.11.0rc2 was released on Monday, September 12, 2022. This is the last preview version before the final release of Python 3.11.0:

Only reviewed changes that fix bugs are allowed during the release candidate phase. There will be very few, if any, code changes between this release candidate and the final release. As listed in the release post, the new features of the 3.11 series, as compared to 3.10, include the following:

PEP 657 – Include Fine-Grained Error Locations in Tracebacks
PEP 654 – Exception Groups and except*
PEP 680 – tomllib: Support for Parsing TOML in the Standard Library
PEP 673 – Self Type
PEP 646 – Variadic Generics
PEP 675 – Arbitrary Literal String Type
PEP 655 – Marking individual TypedDict items as required or potentially-missing
PEP 681 – Data Class Transforms

Python 3.11 also comes with a couple of other exciting updates. gh-90908 introduces task groups to asyncio, and gh-34627 allows for atomic grouping ((?>…)) and possessive quantifiers (*+, ++, ?+, {m,n}+) in regular expressions.

Plus, Python 3.11 is going to deliver faster performance:

The Faster CPython Project is already yielding some exciting results. Python 3.11 is up to 10-60% faster than Python 3.10. On average, we measured a 1.22x speedup on the standard benchmark suite. See Faster CPython for details. (Source)

To dive deeper into some of these cool new features of Python 3.11, check out the following resources depending on your specific needs and interests:

Read the full article at https://realpython.com/python-news-september-2022/ »

[ 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 #128: Using a Memory Profiler in Python & What It Can Teach You

2022-10-07T12:00:00+00:00

Have you used a memory profiler to gauge the performance of your Python application? Maybe you're using it to troubleshoot memory issues when loading a large data science project. What could running a profiler show you about a codebase you're learning? This week on the show, Pablo Galindo Salgado returns to talk about Memray, a powerful tracing memory profiler.

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

Minimax in Python: Learn How to Lose the Game of Nim

2022-10-05T14:00:00+00:00

Games are fun! Their well-defined rules let you explore different strategies in search of a surefire way to win. The minimax algorithm is used to choose the optimal move at any point in a game. You’ll learn how to implement a minimax player in Python that can play the game of Nim perfectly.

In this tutorial, you’ll focus on minimax. However, to visualize how the algorithm works, it’s nice to work with a concrete game. You’ll learn the rules of Nim, which is a game with simple rules and limited choices. Using Nim in the examples allows you to focus on the principles of minimax without getting lost in game rules.

As you follow this tutorial, you’ll:

Learn the principles of the minimax algorithm
Play several variants of the game of Nim
Implement the minimax algorithm
Lose Nim against a minimax player
Use alpha-beta pruning to optimize the minimax algorithm

You can download the source code used in this tutorial, as well as a game simulator where you can play different variants of Nim against a minimax opponent, by clicking the link below:

Source Code: Click here to download the free source code that you’ll use to lose the game of Nim against your minimax player.

Play a Simplified Game of Nim

The roots of Nim go back a long time. While variants of the game have been played throughout history, Nim got its name in 1901 when Charles L. Bouton published Nim, a Game With a Complete Mathematical Theory.

Nim is a game for two players, which always ends with one player winning. The game consists of several counters lying on the game table and the players taking turns removing one or more counters. In the first half of this tutorial, you’ll play a simplified version of Nim with the following rules:

There are several counters in a shared pile.
Two players take alternating turns.
On their turn, a player removes one, two, or three counters from the pile.
The player that takes the last counter loses the game.

You’ll refer to this game as Simple-Nim. Later, you’ll learn the rules of regular Nim. They’re not much more complicated, but Simple-Nim is easier to reason about.

Note: Now it’s time to play! You’re going to start with the analog version, so clear a space on your desk. Play a few rounds of Simple-Nim to get a feel for the rules. Along the way, keep an eye out for any winning strategy that you come across.

You can use any objects that you happen to have available as counters, or you can use a notepad to keep track of the current number of counters in play. Somewhere between ten and twenty counters is a good starting point for a game.

If you don’t have an opponent nearby, you can play against yourself for now. By the end of the tutorial, you’ll have programmed an opponent that you can play against.

To demonstrate the rules, two players—Mindy and Maximillian—will play a game of Simple-Nim, starting with twelve counters. Mindy goes first:

Mindy takes two counters, leaving ten in the pile.
Maximillian takes one counter, leaving nine in the pile.
Mindy takes three counters, leaving six in the pile.
Maximillian takes two counters, leaving four in the pile.
Mindy takes three counters, leaving one in the pile.
Maximillian takes the last counter and loses the game.

In this game, Maximillian takes the last counter, so Mindy is the winner.

Nim, including Simple-Nim, is an intriguing game because the rules are simple enough that the game can be completely analyzed. You’ll use Nim to explore the minimax algorithm, which is able to play the game perfectly. This means that a minimax player will always win the game if at all possible.

Get to Know the Minimax Algorithm

Games have been a fertile ground for inventing and testing artificial intelligence algorithms. Games are well suited to this kind of research because of their clearly defined rules. One of the most famous algorithms is minimax. The name describes how one player tries to maximize their score while the other player tries to minimize it.

Minimax can be applied to many different games and more general decisions. In this tutorial, you’ll learn how to teach minimax to play Nim. However, you can use the same principles in other games, like tic-tac-toe and chess, as well.

Explore Game Trees

Recall the game that Mindy and Maximillian played in the previous section. The following table shows all the moves of the game:

Mindy	Pile	Maximillian
	🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙
🪙🪙	🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙
	🪙🪙🪙🪙🪙🪙🪙🪙🪙	🪙
🪙🪙🪙	🪙🪙🪙🪙🪙🪙
	🪙🪙🪙🪙	🪙🪙
🪙🪙🪙	🪙
		🪙

This representation of the game explicitly shows how many counters each player removed on their turn. However, there’s some redundant information in the table. You can represent the same game by only keeping track of the number of counters in the pile and whose turn it is:

Player to move	Pile
Mindy	🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙 (12)
Maximillian	🪙🪙🪙🪙🪙🪙🪙🪙🪙🪙 (10)
Mindy	🪙🪙🪙🪙🪙🪙🪙🪙🪙 (9)
Maximillian	🪙🪙🪙🪙🪙🪙 (6)
Mindy	🪙🪙🪙🪙 (4)
Maximillian	🪙 (1)

While the number of counters each player removed on their turn isn’t explicitly spelled out, you can work it out by comparing the number of counters in the pile before and after a turn.

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

[ 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: Strings and String Methods

2022-10-04T14:00:00+00:00

Many programmers, regardless of their specialty, deal with text on a daily basis. For example, web developers work with text input from web forms. Data scientists process text to extract data and perform tasks like sentiment analysis, which can help identify and classify opinions in a body of text.

Collections of text in Python are called strings. Special functions called string methods are used to manipulate strings. There are string methods for changing a string from lowercase to uppercase, removing whitespace from the beginning or end of a string, replacing parts of a string with different text, and much more.

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

Manipulate strings with string methods
Work with user input
Deal with strings of numbers
Format strings for printing

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.

[ 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 Enumerations of Constants With Python's Enum

2022-10-03T14:00:00+00:00

Some programming languages, like Java and C++, include syntax that supports a data type known as enumerations, or just enums. This data type allows you to create sets of semantically related constants that you can access through the enumeration itself. Python doesn’t have a dedicated syntax for enums. However, the Python standard library has an enum module that supports enumerations through the Enum class.

If you come from a language with enumerations, and you’re used to working with them, or if you just want to learn how to use enumerations in Python, then this tutorial is for you.

In this tutorial, you’ll learn how to:

Create enumerations of constants using Python’s Enum class
Work with enumerations and their members in Python
Customize enumeration classes with new functionalities
Code practical examples to understand why you would use enumerations

Additionally, you’ll explore other specific enumeration types that live in enum, including IntEnum, IntFlag, and Flag. They’ll help you create specialized enums.

To follow along with this tutorial, you should be familiar with object-oriented programming and inheritance in Python.

Source Code: Click here to download the free source code that you’ll use to build enumerations in Python.

Getting to Know Enumerations in Python

Several programming languages, including Java and C++, have a native enumeration or enum data type as part of their syntax. This data type allows you to create sets of named constants, which are considered members of the containing enum. You can access the members through the enumeration itself.

Enumerations come in handy when you need to define an immutable and discrete set of similar or related constant values that may or may not have semantic meaning in your code.

Days of the week, months and seasons of the year, Earth’s cardinal directions, a program’s status codes, HTTP status codes, colors in a traffic light, and pricing plans of a web service are all great examples of enumerations in programming. In general, you can use an enum whenever you have a variable that can take one of a limited set of possible values.

Python doesn’t have an enum data type as part of its syntax. Fortunately, Python 3.4 added the enum module to the standard library. This module provides the Enum class for supporting general-purpose enumerations in Python.

Enumerations were introduced by PEP 435, which defines them as follows:

An enumeration is a set of symbolic names bound to unique, constant values. Within an enumeration, the values can be compared by identity, and the enumeration itself can be iterated over. (Source)

Before this addition to the standard library, you could create something similar to an enumeration by defining a sequence of similar or related constants. To this end, Python developers often used the following idiom:

>>>

>>> RED, GREEN, YELLOW = range(3)

>>> RED
0

>>> GREEN
1

Even though this idiom works, it doesn’t scale well when you’re trying to group a large number of related constants. Another inconvenience is that the first constant will have a value of 0, which is falsy in Python. This can be an issue in certain situations, especially those involving Boolean tests.

Note: If you’re using a Python version before 3.4, then you can create enumerations by installing the enum34 library, which is a backport of the standard-library enum. The aenum third-party library could be an option for you as well.

In most cases, enumerations can help you avoid the drawbacks of the above idiom. They’ll also help you produce more organized, readable, and robust code. Enumerations have several benefits, some of which relate to ease of coding:

Allowing for conveniently grouping related constants in a sort of namespace
Allowing for additional behavior with custom methods that operate on either enum members or the enum itself
Providing quick and flexible access to enum members
Enabling direct iteration over members, including their names and values
Facilitating code completion within IDEs and editors
Enabling type and error checking with static checkers
Providing a hub of searchable names
Mitigating spelling mistakes when using the members of an enumeration

They also make your code robust by providing the following benefits:

Ensuring constant values that can’t be changed during the code’s execution
Guaranteeing type safety by differentiating the same value shared across several enums
Improving readability and maintainability by using descriptive names instead of mysterious values or magic numbers
Facilitating debugging by taking advantage of readable names instead of values with no explicit meaning
Providing a single source of truth and consistency throughout the code

Now that you know the basics of enumerations in programming and in Python, you can start creating your own enum types by using Python’s Enum class.

Creating Enumerations With Python’s `Enum`

Python’s enum module provides the Enum class, which allows you to create enumeration types. To create your own enumerations, you can either subclass Enum or use its functional API. Both options will let you define a set of related constants as enum members.

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

[ 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 #127: Explaining Access Control Using Python & Cautiously Handling Pickles

2022-09-30T12:00:00+00:00

Have you ever used code to help explain a topic? How can Python scripts be used to understand the intricacies of access control? 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 ]

Custom Python Strings: Inheriting From str vs UserString

2022-09-28T14:00:00+00:00

The Python str class has many useful features that can help you out when you’re processing text or strings in your code. However, in some situations, all these great features may not be enough for you. You may need to create custom string-like classes. To do this in Python, you can inherit from the built-in str class directly or subclass UserString, which lives in the collections module.

In this tutorial, you’ll learn how to:

Create custom string-like classes by inheriting from the built-in str class
Build custom string-like classes by subclassing UserString from the collections module
Decide when to use str or UserString to create custom string-like classes

Meanwhile, you’ll write a few examples that’ll help you decide whether to use str or UserString when you’re creating your custom string classes. Your choice will mostly depend on your specific use case.

To follow along with this tutorial, it’ll help if you’re familiar with Python’s built-in str class and its standard features. You’ll also need to know the basics of object-oriented programming and inheritance in Python.

Sample Code: Click here to download the free sample code that you’ll use to create custom string-like classes.

Creating String-Like Classes in Python

The built-in str class allows you to create strings in Python. Strings are sequences of characters that you’ll use in many situations, especially when working with textual data. From time to time, the standard functionalities of Python’s str may be insufficient to fulfill your needs. So, you may want to create custom string-like classes that solve your specific problem.

You’ll typically find at least two reasons for creating custom string-like classes:

Extending the regular string by adding new functionality
Modifying the standard string’s functionality

You can also face situations in which you need to both extend and modify the standard functionality of strings at the same time.

In Python, you’ll commonly use one of the following techniques to create your string-like classes. You can inherit from the Python built-in str class directly or subclass UserString from collections.

Note: In object-oriented programming, it’s common practice to use the verbs inherit and subclass interchangeably.

One relevant feature of Python strings is immutability, which means that you can’t modify them in place. So, when selecting the appropriate technique to create your own custom string-like classes, you need to consider whether your desired features will affect immutability or not.

For example, if you need to modify the current behavior of existing string methods, then you’ll probably be okay subclassing str. In contrast, if you need to change how strings are created, then inheriting from str will demand advanced knowledge. You’ll have to override the .__new__() method. In this latter case, inheriting from UserString may make your life easier because you won’t have to touch .__new__().

In the upcoming sections, you’ll learn the pros and cons of each technique so that you can decide which is the best strategy to use for your specific problem.

Inheriting From Python’s Built-in `str` Class

For a long time, it was impossible to inherit directly from Python types implemented in C. Python 2.2 fixed this issue. Now you can subclass built-in types, including str. This new feature is quite convenient when you need to create custom string-like classes.

By inheriting from str directly, you can extend and modify the standard behavior of this built-in class. You can also tweak the instantiation process of your custom string-like classes to perform transformations before new instances are ready.

Extending the String’s Standard Behavior

An example of requiring a custom string-like class is when you need to extend the standard Python strings with new behavior. For example, say that you need a string-like class that implements a new method to count the number of words in the underlying string.

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

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

Sneaky REST APIs With Django Ninja

2022-09-27T13:00:00+00:00

Many web projects have moved to the single-page application model. To use this model with Django, you build a project where Django is the back end accessed through a REST API. The Django Ninja library is a FastAPI-inspired tool kit for turning Django views into REST API endpoints with very little extra code. Along the way, you’ll be using curl, a command-line tool that allows you to grab the contents of a web page.

If you’d like to quickly build API endpoints and learn the ways of the Ninja, you’re in the right place.

In this course, you’ll learn about:

REST APIs
Django Ninja
URL arguments and query strings
Serialization through Schema and ModelSchema classes
CRUD operations
Authentication
Error management

[ 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 Add Python to PATH

2022-09-26T14:00:00+00:00

You may need to add Python to PATH if you’ve installed Python, but typing python on the command line doesn’t seem to work. You may be getting a message saying that the term python isn’t recognized, or you may end up with the wrong version of Python running.

A common fix for these problems is adding Python to the PATH environment variable. In this tutorial, you’ll learn how to add Python to PATH. You’ll also learn about what PATH is and why PATH is vital for programs like the command line to be able to find your Python installation.

Note: A path is the address of a file or folder on your hard drive. The PATH environment variable, also referred to as just PATH or Path, is a list of paths to directories that your operating system keeps and uses to find executable scripts and programs.

The steps that you’ll need to take to add something to PATH will depend significantly on your operating system (OS), so be sure to skip to the relevant section if you’re only interested in this procedure for one OS.

Note that you can use the following steps to add any program to PATH, not just Python.

Supplemental Code: Click here to download free supplemental code that’ll walk you through changing PATH across operating systems.

How to Add Python to `PATH` on Windows

The first step is to locate the directory in which your target Python executable lives. The path to the directory is what you’ll be adding to the PATH environment variable.

To find the Python executable, you’ll need to look for a file called python.exe. The Python executable could be in a directory in C:\Python\ or in your AppData\ folder, for instance. If the executable were in AppData\, then the path would typically look something like this:

C:\Users\<USER>\AppData\Local\Programs\Python

In your case, the <USER> part would be replaced by your currently logged-in user name.

Once you’ve found the executable, make sure it works by double-clicking it and verifying that it starts up a Python REPL in a new window.

If you’re struggling to find the right executable, you can use Windows Explorer’s search feature. The issue with the built-in search is that it’s painfully slow. To perform a super-fast full system search for any file, a great alternative is Everything:

Those paths highlighted in yellow, namely those at \WindowsApps and \Python310, would be ideal candidates to add to PATH because they look like executables at the root level of an installation. Those highlighted in red wouldn’t be suitable because some are part of a virtual environment—you can see venv in the path—and some are shortcuts or internal Windows installations.

You may also encounter Python executables that are installed within the folder for a different program. This is due to the fact that many applications bundle their own version of Python within them. These bundled Python installations would also be unsuitable.

Once you’ve located your Python executable, open the Start menu and search for the Edit the system environment variables entry, which opens up a System Properties window. In the Advanced tab, click on the button Environment Variables. There you’ll see User and System variables, which you’ll be able to edit:

In the section entitled User Variables, double-click on the entry that says Path. Another window will pop up showing a list of paths. Click the New button and paste the path to your Python executable there. Once that’s inserted, select your newly added path and click the Move Up button until it’s at the top.

Read the full article at https://realpython.com/add-python-to-path/ »

[ 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 #126: Python as an Efficiency Tool for Non-Developers

2022-09-23T12:00:00+00:00

Are you interested in using Python in an industry outside of software development? Would adding a few custom software tools increase efficiency and make your coworkers' jobs easier? This week on the show, Josh Burnett talks about using Python as a mechanical engineer.

[ 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 Does if name == "main" Do in Python?

2022-09-21T14:00:00+00:00

You’ve likely encountered Python’s if __name__ == "__main__" idiom when reading other people’s code. No wonder—it’s widespread! You might have even used if __name__ == "__main__" in your own scripts. But did you use it correctly?

Maybe you’ve programmed in a C-family language like Java before, and you wonder whether this construct is a clumsy accessory to using a main() function as an entry point.

Syntactically, Python’s if __name__ == "__main__" idiom is just a normal conditional block:

 1if __name__ == "__main__":
 2    ...

The indented block starting in line 2 contains all the code that Python will execute when the conditional statement in line 1 evaluates to True. In the code example above, the specific code logic that you’d put in the conditional block is represented with a placeholder ellipsis (...).

So—if there’s nothing special about the if __name__ == "__main__" idiom, then why does it look confusing, and why does it continue to spark discussion in the Python community?

If the idiom still seems a little cryptic, and you’re not completely sure what it does, why you might want it, and when to use it, then you’ve come to the right place! In this tutorial, you’ll learn all about Python’s if __name__ == "__main__" idiom—starting with what it really does in Python, and ending with a suggestion for a quicker way to refer to it.

Source Code: Click here to download the free source code that you’ll use to understand the name-main idiom.

In Short: It Allows You to Execute Code When the File Runs as a Script, but Not When It’s Imported as a Module

For most practical purposes, you can think of the conditional block that you open with if __name__ == "__main__" as a way to store code that should only run when your file is executed as a script.

You’ll see what that means in a moment. For now, say you have the following file:

 1# echo.py
 2
 3def echo(text: str, repetitions: int = 3) -> str:
 4    """Imitate a real-world echo."""
 5    echoed_text = ""
 6    for i in range(repetitions, 0, -1):
 7        echoed_text += f"{text[-i:]}\n"
 8    return f"{echoed_text.lower()}."
 9
10if __name__ == "__main__":
11    text = input("Yell something at a mountain: ")
12    print(echo(text))

In this example, you define a function, echo(), that mimics a real-world echo by gradually printing fewer and fewer of the final letters of the input text.

Below that, in lines 10 to 12, you use the if __name__ == "__main__" idiom. This code starts with the conditional statement if __name__ == "__main__" in line 10. In the indented lines, 11 and 12, you then collect user input and call echo() with that input. These two lines will execute when you run echo.py as a script from your command line:

$ python echo.py
Yell something at a mountain: HELLOOOO ECHOOOOOOOOOO
ooo
oo
o
.

When you run the file as a script by passing the file object to your Python interpreter, the expression __name__ == "__main__" returns True. The code block under if then runs, so Python collects user input and calls echo().

Try it out yourself! You can download all the code files that you’ll use in this tutorial from the link below:

Source Code: Click here to download the free source code that you’ll use to understand the name-main idiom.

At the same time, if you import echo() in another module or a console session, then the nested code won’t run:

>>>

>>> from echo import echo
>>> print(echo("Please help me I'm stuck on a mountain"))
ain
in
n
.

In this case, you want to use echo() in the context of another script or interpreter session, so you won’t need to collect user input. Running input() would mess with your code by producing a side effect when importing echo.

When you nest the code that’s specific to the script usage of your file under the if __name__ == "__main__" idiom, then you avoid running code that’s irrelevant for imported modules.

Nesting code under if __name__ == "__main__" allows you to cater to different use cases:

Script: When run as a script, your code prompts the user for input, calls echo(), and prints the result.
Module: When you import echo as a module, then echo() gets defined, but no code executes. You provide echo() to the main code session without any side effects.

By implementing the if __name__ == "__main__" idiom in your code, you set up an additional entry point that allows you to use echo() right from the command line.

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

Building Python Project Documentation With MkDocs

2022-09-20T14:00:00+00:00

In this course, you’ll learn how to quickly build documentation for a Python package using MkDocs and mkdocstrings. These tools allow you to generate nice-looking and modern documentation from Markdown files and your code’s docstrings.

Maintaining auto-generated documentation means less effort because you’re linking information between your code and the documentation pages. However, good documentation is more than just the technical description pulled from your code! Your project will appeal more to users if you guide them through examples and connect the dots between the docstrings.

The Material for MkDocs theme makes your documentation look good without any extra effort and is used by popular projects such as Typer CLI and FastAPI.

In this course, you’ll:

Work with MkDocs to produce static pages from Markdown
Pull in code documentation from docstrings using mkdocstrings
Follow best practices for project documentation
Use the Material for MkDocs theme to make your documentation look good
Host your documentation on GitHub Pages

[ 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 #125: Improve Matplotlib With Style Sheets & Python Async for the Web

2022-09-16T12:00:00+00:00

Have you thought the standard output from Matplotlib is a bit generic looking? Would you like a quick way to add style and consistency to your data visualizations? 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: Conditional Logic and Control Flow

2022-09-13T14:00:00+00:00

Much of the Python code you’ll write is unconditional. That is, the code does not make any choices. Every line of code is executed in the order that it’s written or in the order that functions are called, with possible repetitions inside loops.

In this course, you’ll learn how to use conditional logic to write programs that perform different actions based on different conditions. Paired with functions and loops, conditional logic allows you to write complex programs that can handle many different situations.

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

Compare the values of two or more variables
Write if statements to control the flow of your programs
Handle errors with try and except
Apply conditional logic to create simulations

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.

[ 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 #124: Exploring Recursion in Python With Al Sweigart

2022-09-09T12:00:00+00:00

Have you wanted to understand recursion and how to use it in Python? Are you familiar with the call stack and how it relates to tracebacks? This week on the show, Al Sweigart talks about his new book, "The Recursive Book of Recursion."

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

Building Command Line Interfaces With argparse

2022-09-06T14:00:00+00:00

One of the strengths of Python is that it comes with batteries included: it has a rich and versatile standard library that makes it one of the best programming languages for writing scripts for the command line. But, if you write scripts for the command line, then you also need to provide a good command line interface, which you can create with the Python argparse library.

In this video course, you’ll learn:

What the Python argparse library is, and why it’s important to use it if you need to write command line scripts in Python
How to use the Python argparse library to quickly create a simple CLI in Python
What the advanced usage of the Python argparse library is

This video course is for early intermediate Pythonistas who probably write scripts in Python for their everyday work but have never implemented a command line interface for their scripts.

If that sounds like you, and you’re used to setting variable values at the beginning of your scripts or manually parsing the sys.argv system list instead of using a more robust CLI development tool, then this video course is 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 #123: Creating a Python Code Completer & More Abstract Syntax Tree Projects

2022-09-02T12:00:00+00:00

How does a code completion tool work? What is an Abstract Syntax Tree, and how is it created in Python? How does an AST help you write programs and projects that inspect and modify your Python code? This week on the show, Meredydd Luff, co-founder of Anvil, shares his PyCon talk, "Building a Python Code Completer."

[ 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: Functions and Loops

2022-08-30T14:00:00+00:00

Functions are the building blocks of almost every Python program. They’re where the real action takes place!

In your Python Basics journey, you’ve probably encountered functions such as print(), len(), and round(). These are all built-in functions because they come built into the Python language itself. You can also create user-defined functions that perform specific tasks.

Functions break code into smaller chunks and are great for defining actions that a program will execute several times throughout your code. Instead of writing the same code each time the program needs to perform the same task, just call the function!

But sometimes you do need to repeat some code several times in a row. This is where loops come in.

In this Python Basics video course, you’ll learn:

How to create user-defined functions
How to write for and while loops

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.

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

Building a URL Shortener With FastAPI and Python

2022-08-23T14:00:00+00:00

In this video course, you’ll build a URL shortener with Python and FastAPI. URLs can be extremely long and not user-friendly. This is where a URL shortener can come in handy. A URL shortener reduces the number of characters in a URL, making it easier to read, remember, and share.

By following this step-by-step project, you’ll build a URL shortener with Python and FastAPI. At the end of this course, you’ll have a fully functional API-driven web app that creates shortened URLs that forward to target URLs.

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

Create a REST API with FastAPI
Run a development web server with Uvicorn
Model an SQLite database
Investigate the auto-generated API documentation
Interact with the database with CRUD actions
Optimize your app by refactoring your code

This URL shortener project is for intermediate Python programmers who want to try out FastAPI and learn about API design, CRUD, and interaction with a database. To follow along, it’ll help if you’re familiar with the basics of handling HTTP requests. If you need a refresher on FastAPI, Using FastAPI to Build Python Web APIs is a great introduction.

[ 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 #122: Configuring a Coding Environment on Windows & Using TOML With Python

2022-08-19T12:00:00+00:00

Have you attempted to set up a Python development environment on Windows before? Would it be helpful to have an easy-to-follow guide to get you started? 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 ]

Caching in Python With lru_cache

2022-08-16T14:00:00+00:00

There are many ways to achieve fast and responsive applications. Caching is one approach that, when used correctly, makes things much faster while decreasing the load on computing resources.

Python’s functools module comes with the @lru_cache decorator, which gives you the ability to cache the result of your functions using the Least Recently Used (LRU) strategy. This is a simple yet powerful technique that you can use to leverage the power of caching in your code.

In this video course, you’ll learn:

What caching strategies are available and how to implement them using Python decorators
What the LRU strategy is and how it works
How to improve performance by caching with the @lru_cache decorator
How to expand the functionality of the @lru_cache decorator and make it expire after a specific time

By the end of this video course, you’ll have a deeper understanding of how caching works and how to take advantage of it in Python.

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

The Real Python Podcast – Episode #121: Moving NLP Forward With Transformer Models and Attention

2022-08-12T12:00:00+00:00

What's the big breakthrough for Natural Language Processing (NLP) that has dramatically advanced machine learning into deep learning? What makes these transformer models unique, and what defines "attention?" This week on the show, Jodie Burchell, developer advocate for data science at JetBrains, continues our talk about how machine learning (ML) models understand and generate text.

[ 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 3.11: Cool New Features for You to Try

More Informative Error Tracebacks

The Real Python Podcast – Episode #130: Fostering an Internal Python Community & Managing the 3.11 Release

Build a Tic-Tac-Toe Game Engine With an AI Player in Python

Demo: Tic-Tac-Toe AI Player in Python

Project Overview

Python Basics: Numbers and Math

A Practical Introduction to Web Scraping in Python

Scrape and Parse Text From Websites

Build Your First Web Scraper

The Real Python Podcast – Episode #129: Using an Ellipsis in Python & Goals for CPython 3.12

ChatterBot: Build a Chatbot With Python

Demo

Project Overview

Prerequisites

Providing Multiple Constructors in Your Python Classes

Python News: What's New From September 2022?

Python 3.11.0rc2 Was Released

The Real Python Podcast – Episode #128: Using a Memory Profiler in Python & What It Can Teach You

Minimax in Python: Learn How to Lose the Game of Nim

Play a Simplified Game of Nim

Get to Know the Minimax Algorithm

Explore Game Trees

Python Basics: Strings and String Methods

Build Enumerations of Constants With Python's Enum

Getting to Know Enumerations in Python

Creating Enumerations With Python’s Enum

The Real Python Podcast – Episode #127: Explaining Access Control Using Python & Cautiously Handling Pickles

Custom Python Strings: Inheriting From str vs UserString

Creating String-Like Classes in Python

Inheriting From Python’s Built-in str Class

Extending the String’s Standard Behavior

Sneaky REST APIs With Django Ninja

How to Add Python to PATH

How to Add Python to PATH on Windows

The Real Python Podcast – Episode #126: Python as an Efficiency Tool for Non-Developers

What Does if __name__ == "__main__" Do in Python?

In Short: It Allows You to Execute Code When the File Runs as a Script, but Not When It’s Imported as a Module

Building Python Project Documentation With MkDocs

The Real Python Podcast – Episode #125: Improve Matplotlib With Style Sheets & Python Async for the Web

Python Basics: Conditional Logic and Control Flow

The Real Python Podcast – Episode #124: Exploring Recursion in Python With Al Sweigart

Building Command Line Interfaces With argparse

The Real Python Podcast – Episode #123: Creating a Python Code Completer & More Abstract Syntax Tree Projects

Python Basics: Functions and Loops

Building a URL Shortener With FastAPI and Python

The Real Python Podcast – Episode #122: Configuring a Coding Environment on Windows & Using TOML With Python

Caching in Python With lru_cache

The Real Python Podcast – Episode #121: Moving NLP Forward With Transformer Models and Attention

Creating Enumerations With Python’s `Enum`

Inheriting From Python’s Built-in `str` Class

How to Add Python to `PATH` on Windows

What Does if name == "main" Do in Python?