Real Python

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 ]

When Do You Use an Ellipsis in Python?

2022-09-19T14:00:00+00:00

In English writing, you can use the ellipsis to indicate that you’re leaving something out. Essentially, you use three dots (...) to replace the content. But the ellipsis doesn’t only exist in prose—you may have seen three dots in Python source code, too.

The ellipsis literal (...) evaluates to Python’s Ellipsis. Because Ellipsis is a built-in constant, you can use Ellipsis or ... without importing it:

>>>

>>> ...
Ellipsis

>>> Ellipsis
Ellipsis

>>> ... is Ellipsis
True

Although three dots may look odd as Python syntax, there are situations where using ... can come in handy. But when should you use Ellipsis in Python?

Source Code: Click here to download the free source code that you’ll use to master the ellipsis literal.

In Short: Use the Ellipsis as a Placeholder in Python

While you can use ... and Ellipsis interchangeably, you’ll commonly opt for ... in your code. Similar to using three dots in English to omit content, you can use the ellipsis in Python as a placeholder for unwritten code:

# ellipsis_example.py

def do_nothing():
    ...

do_nothing()

When you run ellipsis_example.py and execute do_nothing(), then Python runs without complaining:

$ python ellipsis_example.py
$

There’s no error when you execute a function in Python that contains only ... in the function body. That means you can use an ellipsis as a placeholder similar to the pass keyword.

Using three dots creates minimal visual clutter. So, it can be convenient to replace irrelevant code when you’re sharing parts of your code online.

A common time when you omit code is when you work with stubs. You can think of stubs as stand-ins for real functions. Stubs can come in handy when you only need a function signature but don’t want to execute the code in the function body. For example, you’d probably want to prevent external requests when you’re developing an application.

Say you have a Flask project where you’ve created your own visitor counter in custom_stats.count_visitor(). The count_visitor() function is connected to the database where you track the number of visitors. To not count yourself when you test your application in debug mode, you can create a stub of count_visitor():

 1# app.py
 2
 3from flask import Flask
 4
 5from custom_stats import count_visitor
 6
 7app = Flask(__name__)
 8
 9if app.debug:
10    def count_visitor(): ...
11
12@app.route("/")
13def home():
14    count_visitor()
15    return "Hello, world!"

Because the content of count_visitor() doesn’t matter in this case, it’s a good idea to use the ellipsis in the function body. Python calls count_visitor() without error or unwanted side effects when you run your Flask application in debug mode:

$ flask --app app --debug run
 * Serving Flask app 'app'
 * Debug mode: on

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

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

How to Replace a String in Python

2022-09-14T14:00:00+00:00

If you’re looking for ways to remove or replace all or part of a string in Python, then this tutorial is for you. You’ll be taking a fictional chat room transcript and sanitizing it using both the .replace() method and the re.sub() function.

In Python, the .replace() method and the re.sub() function are often used to clean up text by removing strings or substrings or replacing them. In this tutorial, you’ll be playing the role of a developer for a company that provides technical support through a one-to-one text chat. You’re tasked with creating a script that’ll sanitize the chat, removing any personal data and replacing any swear words with emoji.

You’re only given one very short chat transcript:

[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!

Even though this transcript is short, it’s typical of the type of chats that agents have all the time. It has user identifiers, ISO time stamps, and messages.

In this case, the client johndoe filed a complaint, and company policy is to sanitize and simplify the transcript, then pass it on for independent evaluation. Sanitizing the message is your job!

Sample Code: Click here to download the free sample code that you’ll use to replace strings in Python.

The first thing you’ll want to do is to take care of any swear words.

How to Remove or Replace a Python String or Substring

The most basic way to replace a string in Python is to use the .replace() string method:

>>>

>>> "Fake Python".replace("Fake", "Real")
'Real Python'

As you can see, you can chain .replace() onto any string and provide the method with two arguments. The first is the string that you want to replace, and the second is the replacement.

Note: Although the Python shell displays the result of .replace(), the string itself stays unchanged. You can see this more clearly by assigning your string to a variable:

>>>

>>> name = "Fake Python"
>>> name.replace("Fake", "Real")
'Real Python'

>>> name
'Fake Python'

>>> name = name.replace("Fake", "Real")
'Real Python'

>>> name
'Real Python'

Notice that when you simply call .replace(), the value of name doesn’t change. But when you assign the result of name.replace() to the name variable, 'Fake Python' becomes 'Real Python'.

Now it’s time to apply this knowledge to the transcript:

>>>

>>> transcript = """\
... [support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
... [johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY BLASTED ACCOUNT
... [support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
... [johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!"""

>>> transcript.replace("BLASTED", "😤")
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY 😤 ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : Blast! You're right!

Loading the transcript as a triple-quoted string and then using the .replace() method on one of the swear words works fine. But there’s another swear word that’s not getting replaced because in Python, the string needs to match exactly:

>>>

>>> "Fake Python".replace("fake", "Real")
'Fake Python'

As you can see, even if the casing of one letter doesn’t match, it’ll prevent any replacements. This means that if you’re using the .replace() method, you’ll need to call it various times with the variations. In this case, you can just chain on another call to .replace():

>>>

>>> transcript.replace("BLASTED", "😤").replace("Blast", "😤")
[support_tom] 2022-08-24T10:02:23+00:00 : What can I help you with?
[johndoe] 2022-08-24T10:03:15+00:00 : I CAN'T CONNECT TO MY 😤 ACCOUNT
[support_tom] 2022-08-24T10:03:30+00:00 : Are you sure it's not your caps lock?
[johndoe] 2022-08-24T10:04:03+00:00 : 😤! You're right!

Success! But you’re probably thinking that this isn’t the best way to do this for something like a general-purpose transcription sanitizer. You’ll want to move toward some way of having a list of replacements, instead of having to type out .replace() each time.

Read the full article at https://realpython.com/replace-string-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: Conditional Logic & 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 ]

Custom Python Lists: Inheriting From list vs UserList

2022-09-12T14:00:00+00:00

At some point in your Python coding adventure, you may need to create custom list-like classes with modified behavior, new functionalities, or both. To do this in Python, you can inherit from an abstract base class, subclass the built-in list class directly, or inherit from UserList, which lives in the collections module.

In this tutorial, you’ll learn how to:

Create custom list-like classes by inheriting from the built-in list class
Build custom list-like classes by subclassing UserList from the collections module

You’ll also write some examples that’ll help you decide which parent class, list or UserList, to use when creating your custom list classes.

To get the most out of this tutorial, you should be familiar with Python’s built-in list class and its standard features. You’ll also need to know the basics of object-oriented programming and understand how inheritance works in Python.

Free Download: Click here to download the source code that you’ll use to create custom list-like classes.

Creating List-Like Classes in Python

The built-in list class is a fundamental data type in Python. Lists are useful in many situations and have tons of practical use cases. In some of these use cases, the standard functionality of Python list may be insufficient, and you may need to create custom list-like classes to address the problem at hand.

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

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

You can also face situations in which you need to both extend and modify the list’s standard functionality.

Depending on your specific needs and skill level, you can use a few strategies to create your own custom list-like classes. You can:

Inherit from an appropriate abstract base class, such as MutableSequence
Inherit from the Python built-in list class directly
Subclass UserList from collections

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

There are a few considerations when you’re selecting the appropriate strategy to use. Keep reading for more details.

Building a List-Like Class From an Abstract Base Class

You can create your own list-like classes by inheriting from an appropriate abstract base class (ABC), like MutableSequence. This ABC provides generic implementations of most list methods except for .__getitem__(), .__setitem__(), .__delitem__, .__len__(), and .insert(). So, when inheriting from this class, you’ll have to implement these methods yourself.

Writing your own implementation for all these special methods is a fair amount of work. It’s error-prone and requires advanced knowledge of Python and its data model. It can also imply performance issues because you’ll be writing the methods in pure Python.

Additionally, suppose you need to customize the functionality of any other standard list method, like .append() or .insert(). In that case, you’ll have to override the default implementation and provide a suitable implementation that fulfills your needs.

The main advantage of this strategy for creating list-like classes is that the parent ABC class will alert you if you miss any required methods in your custom implementation.

In general, you should embrace this strategy only if you need a list-like class that’s fundamentally different from the built-in list class.

In this tutorial, you’ll focus on creating list-like classes by inheriting from the built-in list class and the UserList class from the standard-library collections module. These strategies seem to be the quickest and most practical ones.

Inheriting From Python’s Built-in `list` 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 list. This change has brought several technical advantages to the subclasses because now they:

Will work in every place that requires the original built-in type
Can define new instance, static, and class methods
Can store their instance attributes in a .__slots__ class attribute, which essentially replaces the .__dict__ attribute

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

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

HTML and CSS for Python Developers

2022-09-07T14:00:00+00:00

When you want to build websites as a Python programmer, there’s no way around HTML and CSS. Almost every website on the Internet is built with HTML markup to structure the page. To make a website look nice, you can style HTML with CSS.

If you’re interested in web development with Python, then knowing HTML and CSS will help you understand web frameworks like Django and Flask better. But even if you’re just getting started with Python, HTML and CSS can enable you to create small websites to impress your friends.

In this tutorial, you’ll learn how to:

Structure a basic HTML file
View and inspect HTML in your browser
Insert images and page links
Style a website with CSS
Format HTML with accessibility in mind
Use Python to write and parse HTML code

You’ll get an introduction to HTML and CSS that you can follow along with. Throughout this tutorial, you’ll build a website with three pages and CSS styling:

While creating the web project, you’ll craft a boilerplate HTML document that you can use in your upcoming web projects. You may find that the source code will come in handy when you’re working on future projects. You can download it here:

Free Bonus: Click here to download the supplemental materials for this tutorial, including a time-saving HTML template file.

After learning the basics of HTML and CSS, you’ll find ideas on how to continue your journey at the end of the tutorial.

Create Your First HTML File

Think of any website that you’ve recently visited. Maybe you read some news, chatted with friends, or watched a video. No matter what kind of website it was, you can bet that its source code has a basic <html> tag at the beginning.

HTML stands for HyperText Markup Language. HTML was created by Tim Berners-Lee, whose name might also ring a bell for you as the inventor of the World Wide Web.

The hypertext part of HTML refers to building connections between different HTML pages. With hyperlinks, you can jump between pages and surf the Web.

You use markup to structure content in a document. In contrast to formatting, the markup defines the meaning of content and not how it looks. In this section, you’ll learn about HTML elements and their roles.

Writing semantic HTML code will make your documents accessible for a wide range of visitors. After all, you want to enable everybody to consume your content, whether they’re visiting your page with a browser or using screen reading tools.

For each HTML element, there’s a standard that defines its intended use. Today, the standards of HTML are defined by the Web Hypertext Application Technology Working Group (WHATWG). The WHATWG plays a similar role for HTML as the Python Steering Council does for Python.

Approximately 95 percent of websites use HTML, so you’ll be hard-pressed to avoid it if you want to do any web development work in Python.

In this section, you’ll start by creating your first HTML file. You’ll learn how to structure your HTML code to make it readable for your browser and for humans.

The HTML Document

In this section, you’ll create a basic HTML file. The HTML file will contain the base structure that most websites are built with.

To start things off, create a file named index.html with some text:

 1<!-- index.html -->
 2
 3Am I HTML already?

Traditionally, the first file of your website is called index.html. You can think of the index.html page as akin to the main.py or app.py file in a Python project.

Note: Unless your server is configured differently, index.html is the file that the server tries to load when you visit the root URL. That’s why you can visit https://www.example.com/ instead of typing the full https://www.example.com/index.html address.

So far, the only content of index.html is a plain Am I HTML already? string. You haven’t added any HTML syntax yet, except an HTML comment on line 1. Similar to the Python interpreter not executing comments in your Python code, the browser won’t render the contents of your HTML comments. Still, go ahead and open index.html in your browser:

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

Python News: What's New From August 2022

2022-09-05T14:00:00+00:00

In August 2022, Python inched closer to the 3.11 release, pandas introduced enhancement proposals, various packages saw new releases, Python extended its lead at the top of the TIOBE index, and PyPI battled malware.

Read on for more details about what happened in the world of Python in August 2022!

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

Python Has PEPs, NumPy Has NEPs, pandas Now Has PDEPs

The first pandas enhancement proposal (PDEP) was submitted on August 3, 2022, and was entitled Purpose and guidelines. Enhancement proposals aren’t new to the Python community. Python has had PEPs since 2000, and NumPy followed with NEPs in 2017.

The first PDEP follows in the tradition of PEPs and NEPs, with PDEP-1 being an introduction to the idea behind the enhancement proposals themselves.

In a nutshell, PDEPs are intended to aid the proposal process for major changes to pandas, such as moving a module from the main pandas repository to a break-off repository. PDEPs are not for quick fixes, but for major undertakings that involve the wider community and, more often than not, some significant trade-offs.

Working out complex issues isn’t ideally suited to a thread-based medium, like GitHub issues. It can be hard for a discussion to stay focused if anyone can respond at any time, even if the original idea is a good one.

GitHub issue threads can create noise not only for the core developers, but for contributors and end users too. Additionally, they can bury good but complex ideas by not providing an appropriate medium for discussing them. Contributor h-vetinari raised this topic in a GitHub issue in 2019:

The more intricate the API implications, the harder it is to discuss in GitHub comments (because there is usually too many things to consider at the same time, or the comments/threads get ridiculously long or both). That does not mean that the given change does not have merit though, just that it’s (likely) too hard to discuss in a thread format. (Source)

The GitHub issue that h-vetinari raised three years ago has now been closed with the pull request for PDEP-1. This may lay a blueprint for the PDEP life cycle going forward. PDEPs will probably get started when someone creates an issue. If the issue is recognized as being significant and valuable, then the person who raised it may be directed to create a PDEP.

This move to PDEPs means that the roadmap that’s typically used for communicating larger changes to pandas will slowly migrate toward PDEPs.

How do you feel about the move to PDEPs? Share your thoughts in the comments!

Python Ecosystem Celebrates New Releases

The Python community didn’t rest throughout August, even though it’s typically a month for vacations. As usual, there have been plenty of releases in the Python ecosystem. From CPython to CircuitPython, there are plenty of new features for you to start playing with. Read on for a selection of releases and milestones.

CPython

The CPython team is still gearing up for the release of Python 3.11 in October 2022. If you’re interested in learning more about the 3.11 release, check out some in-depth Real Python tutorials exploring the new 3.11 features, such as exception groups, tomllib, and better error messages.

Read the full article at https://realpython.com/python-news-august-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 #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 ]

How Can You Install a Pre-Release Version of Python?

2022-08-31T14:00:00+00:00

The Python language is in constant development. A new version is released annually in October to great fanfare. Before these stable releases, you can preview the new features by installing a pre-release of Python.

Volunteers worldwide work on developing Python by updating the documentation, reporting issues, suggesting and discussing improvements, fixing bugs, and implementing new features. You can join this work and contribute to the efforts.

The best way to start getting involved in the development of Python is to install and test early versions of the next release, whether it’s in the alpha, beta, or release candidate phase. Pablo Galindo Salgado, the release manager for Python 3.10 and 3.11, put it succinctly:

In summary: no matter who you are or what you do. Test the beta releases! (Source)

Python is essential to many people’s workflows and companies’ infrastructures. Therefore, the community must thoroughly test new Python versions before the stable release. You use Python differently from anyone else and may be able to reveal a bug that no one else has discovered. Installing a pre-release version of Python and playing with it is valuable to the ecosystem. Plus, it’s fun!

You’re excited to install an early version of Python and try out the latest features. One question remains: How can you install a pre-release version of Python?

In this tutorial, you’ll learn about some options for getting your hands on an early version of Python and previewing its features.

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

In Short: Use `pyenv` to Manage Several Versions of Python, Including the Latest Pre-Release

You shouldn’t use a pre-release version of Python as the only Python on your computer. By their nature, pre-releases may be unstable or have bugs that can interfere with your day-to-day Python work. You should therefore install the pre-release version side by side with your regular Python.

One great tool for installing and managing several versions of Python on your computer is pyenv. With pyenv, you can install many Python versions on your computer and switch between them with a simple command. You can even set up project-specific Python versions that are automatically invoked.

If you’re not already using pyenv, then you first need to install it. How you install pyenv depends on your operating system. Choose your platform with the switcher below:

If you want an in-depth tutorial on how to use pyenv, then check out Managing Multiple Python Versions With pyenv.

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

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

Python and PyQt: Building a GUI Desktop Calculator

2022-08-29T14:00:00+00:00

Even though web and mobile applications appear to have taken over the software development market, there’s still demand for traditional graphical user interface (GUI) desktop applications. If you’re interested in building these kinds of applications in Python, then you’ll find a wide variety of libraries to choose from. They include Tkinter, wxPython, PyQt, PySide, and a few others.

In this tutorial, you’ll learn the basics of building GUI desktop applications with Python and PyQt.

In this tutorial, you’ll learn how to:

Create graphical user interfaces with Python and PyQt
Connect the user’s events on the app’s GUI with the app’s logic
Organize a PyQt app using a proper project layout
Create a fully functional GUI application with PyQt

For this tutorial, you’ll create a calculator app with Python and PyQt. This short project will help you grasp the fundamentals and get you up and running with this GUI library.

You can download the source code for the project and all examples in this tutorial by clicking on the link below:

Download Code: Click here to download the code that you’ll use to build a calculator in Python with PyQt in this tutorial.

Getting to Know PyQt

PyQt is a Python binding for Qt, which is a set of C++ libraries and development tools providing platform-independent abstractions for graphical user interfaces (GUIs). Qt also provides tools for networking, threads, regular expressions, SQL databases, SVG, OpenGL, XML, and many other powerful features.

Developed by RiverBank Computing Ltd, PyQt’s latest editions are:

PyQt5: An edition that’s built against Qt 5.x only
PyQt6: An edition that’s built against Qt 6.x only

In this tutorial, you’ll use PyQt6, as this version is the future of the library. From now on, be sure to consider any mention of PyQt as a reference to PyQt6.

Note: If you want to dive deeper into the differences between these two versions of the library, then check out the PyQt6 documentation on the topic.

PyQt6 is based on Qt v6. Therefore, it provides classes and tools for GUI creation, XML handling, network communication, regular expressions, threads, SQL databases, web browsing, and other technologies available in Qt. PyQt6 implements binding for many Qt classes in a set of Python modules, which are organized in a top-level Python package called PyQt6. For PyQt6 to work, you need Python 3.6.1 or later.

PyQt6 is compatible with Windows, Unix, Linux, macOS, iOS, and Android. This is an attractive feature if you’re looking for a GUI framework to develop multiplatform applications that have a native look and feel on each platform.

PyQt6 is available under two licenses:

Your PyQt6 license must be compatible with your Qt license. If you use the GPL license, then your code must also use a GPL-compatible license. If you want to use PyQt6 to create commercial applications, then you need a commercial license for your installation.

Note: The Qt Company has developed and currently maintains its own Python binding for the Qt library. The Python library is called Qt for Python and is the official Qt for Python. Its Python package is called PySide.

PyQt and PySide are both built on top of Qt. Their APIs are quite similar because they reflect the Qt API. That’s why porting PyQt code to PySide can be as simple as updating some imports. If you learn one of them, then you’ll be able to work with the other with minimal effort. If you want to dive deeper into the differences between these two libraries, then you can check out PyQt6 vs PySide6.

If you need more information about PyQt6 licensing, then check out the license FAQs page on the project’s official documentation.

Installing PyQt

You have several options for installing PyQt on your system or development environment. The recommended option is to use to use binary wheels. Wheels are the standard way to install Python packages from the Python package index, PyPI.

In any case, you need to consider that wheels for PyQt6 are only available for Python 3.6.1 and later. There are wheels for Linux, macOS, and Windows (64-bit).

All of these wheels include copies of the corresponding Qt libraries, so you won’t need to install them separately.

Another installation option is to build PyQt from source. This can be a bit complicated, so you might want to avoid it if possible. If you really need to build from source, then check out what the library’s documentation recommends in those cases.

Read the full article at https://realpython.com/python-pyqt-gui-calculator/ »

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

Exploring Special Function Parameters

2022-08-09T14:00:00+00:00

Have you ever come across the forward slash (/) and asterisk (*) symbols in the documentation for your favorite libraries? These represent special parameters, which tell you what kinds of arguments you can use to call a given function. In Python, these parameters can help you ensure that your functions are used correctly.

Maybe you’re a regular at Real Python’s weekly Office Hours meetup, or perhaps you’re curious about what happens there. You’ll get a glimpse in this Code Conversation, which answers one participant’s question of how to interpret and apply special function parameters in writing and calling functions.

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

Set default values for arguments
Write positional-only, keyword-only, and combined functions
Refer to the forward slash (/) and asterisk (*) accurately
Use special function parameters in real-world 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 #120: Inspiring Young People to Learn Python With Mission Encodeable

2022-08-05T12:00:00+00:00

Is there someone in your life you'd like to inspire to learn Python? Mission Encodeable is a website designed to teach people to code, built by two high-school students. This week on the show, Anna and Harry Wake talk about creating their site and motivating people to start coding.

[ 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: Finding and Fixing Code Bugs

2022-08-02T14:00:00+00:00

Everyone makes mistakes—even seasoned professional developers!

IDLE is pretty good at catching mistakes like syntax errors and run-time errors, but there’s a third type of error that you may have already experienced. Logic errors occur when an otherwise valid program doesn’t do what was intended.

Logic errors cause unexpected behaviors called bugs. Removing bugs is called debugging, and a debugger is a tool that helps you hunt down bugs and understand why they’re happening.

Knowing how to find and fix bugs in your code is a skill that you will use for your entire coding career!

In this Python Basics video course, you’ll:

Learn how to use IDLE’s Debug Control window
Practice debugging on a buggy function
Learn alternative methods for debugging 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 #119: Natural Language Processing and How ML Models Understand Text

2022-07-29T12:00:00+00:00

How do you process and classify text documents in Python? What are the fundamental techniques and building blocks for Natural Language Processing (NLP)? This week on the show, Jodie Burchell, developer advocate for data science at JetBrains, talks about how machine learning (ML) models understand 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 ]

Managing Attributes With Python's property()

2022-07-26T14:00:00+00:00

With Python’s property(), you can create managed attributes in your classes. You can use managed attributes, also known as properties, when you need to modify their internal implementation without changing the public API of the class. Providing stable APIs can help you avoid breaking your users’ code when they rely on your classes and objects.

Properties are arguably the most popular way to create managed attributes quickly and in the purest Pythonic style.

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

Create managed attributes or properties in your classes
Perform lazy attribute evaluation and provide computed attributes
Avoid setter and getter methods to make your classes more Pythonic
Create read-only, read-write, and write-only properties
Create consistent and backwards-compatible APIs for your classes

[ 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 #118: Creating Documentation With MkDocs & When to Use a Python dict

2022-07-22T12:00:00+00:00

How do you start building your project documentation? What if you had a tool that could do the heavy lifting and automatically write large portions directly from 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 ]

Real Python

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

When Do You Use an Ellipsis in Python?

In Short: Use the Ellipsis as a Placeholder in Python

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

How to Replace a String in Python

How to Remove or Replace a Python String or Substring

Python Basics: Conditional Logic & Control Flow

Custom Python Lists: Inheriting From list vs UserList

Creating List-Like Classes in Python

Building a List-Like Class From an Abstract Base Class

Inheriting From Python’s Built-in list Class

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

HTML and CSS for Python Developers

Create Your First HTML File

The HTML Document

Building Command Line Interfaces With argparse

Python News: What's New From August 2022

Python Has PEPs, NumPy Has NEPs, pandas Now Has PDEPs

Python Ecosystem Celebrates New Releases

CPython

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

How Can You Install a Pre-Release Version of Python?

In Short: Use pyenv to Manage Several Versions of Python, Including the Latest Pre-Release

Python Basics: Functions and Loops

Python and PyQt: Building a GUI Desktop Calculator

Getting to Know PyQt

Installing PyQt

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

Exploring Special Function Parameters

The Real Python Podcast – Episode #120: Inspiring Young People to Learn Python With Mission Encodeable

Python Basics: Finding and Fixing Code Bugs

The Real Python Podcast – Episode #119: Natural Language Processing and How ML Models Understand Text

Managing Attributes With Python's property()

The Real Python Podcast – Episode #118: Creating Documentation With MkDocs & When to Use a Python dict

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

How to Add Python to `PATH` on Windows

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

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

In Short: Use `pyenv` to Manage Several Versions of Python, Including the Latest Pre-Release