Real Python

Using the bpython Enhanced REPL

2023-10-31T14:00:00+00:00

The standard Python interpreter lets you run scripts from files or interactively execute code on the fly in a so-called read-evaluate-print loop (REPL). While this is a powerful tool for exploring the language and discovering its libraries through instant feedback on your code inputs, the default REPL shipped with Python has several limitations. Luckily, alternatives like bpython offer a much more programmer-friendly and convenient experience.

You can use bpython to experiment with your code or quickly test an idea without switching contexts between different programs, just like in an integrated development environment (IDE). In addition, bpython may be a valuable teaching tool in either a virtual or physical classroom.

In this course, you’ll learn how to:

Install and use bpython as your alternative Python REPL
Boost your productivity thanks to bpython’s unique features
Tweak bpython’s configuration and its color theme
Use common keyboard shortcuts to code more quickly
Contribute to bpython’s open-source project on GitHub

Before starting this course, make sure you’re already familiar with Python basics and know how to start the standard Python REPL in the command line. In addition, you should be able to install packages with pip, ideally into a virtual environment.

[ 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 Use Type Hints for Multiple Return Types in Python

2023-10-30T14:00:00+00:00

In Python, type hinting is an optional yet useful feature to make your code easier to read, reason about, and debug. With type hints, you let other developers know the expected data types for variables, function arguments, and return values. As you write code for applications that require greater flexibility, you may need to specify multiple return types to make your code more robust and adaptable to different situations.

You’ll encounter different use cases where you may want to annotate multiple return types within a single function in Python. In other words, the data returned can vary in type. In this tutorial, you’ll walk through examples of how to specify multiple return types for a function that parses a string from an email address to grab the domain name.

In addition, you’ll see examples of how to specify type hints for callback functions or functions that take another function as input. With these examples, you’ll be ready to express type hints in functional programming.

Note: Typically, you want to work with functions that are generous in which type of arguments they accept, while they’re specific about the type of their return value. For example, a function may accept any iterable like a list, tuple, or generator, but always return a list.

If your function can return several different types, then you should first consider whether you can refactor it to have a single return type. In this tutorial, you’ll learn how to deal with those functions that need multiple return types.

To get the most out of this tutorial, you should know the basics of what type hints in Python are and how you use them.

Get Your Code: Click here to get access to the free sample code that shows you how to declare type hints for multiple types in Python.

Use Python’s Type Hints for One Piece of Data of Alternative Types

In this section, you’ll learn how to write type hints for functions that can return one piece of data that could be of different types. The scenarios for considering multiple return types include:

Conditional statements: When a function uses conditional statements that return different types of results, you can convey this by specifying alternative return types for your function using type hints.
Optional values: A function may sometimes return no value, in which case you can use type hints to signal the occasional absence of a return value.
Error handling: When a function encounters an error, you may want to return a specific error object that’s different from the normal results’ return type. Doing so could help other developers handle errors in the code.
Flexibility: When designing and writing code, you generally want it to be versatile, flexible, and reusable. This could mean writing functions that can handle a range of data types. Specifying this in type hints helps other developers understand your code’s versatility and its intended uses in different cases.

In the example below, you use type hints in working with conditional statements. Imagine that you’re processing customer data and want to write a function to parse users’ email addresses to extract their usernames.

To represent one piece of data of multiple types using type hints in Python 3.10 or newer, you can use the pipe operator (|). Here’s how you’d use type hints in a function that typically returns a string containing the username but can also return None if the corresponding email address is incomplete:

Python
      
    
def parse_email(email_address: str) -> str | None:
    if "@" in email_address:
        username, domain = email_address.split("@")
        return username
    return None

In the example above, the parse_email() function has a conditional statement that checks if the email address passed as an argument contains the at sign (@). If it does, then the function splits on that symbol to extract the elements before and after the at sign, stores them in local variables, and returns the username. If the argument doesn’t contain an at sign, then the return value is None, indicating an invalid email address.

Note: In practice, the validation rules for email addresses are much more complicated.

So, the return value of this function is either a string containing the username or None if the email address is incomplete. The type hint for the return value uses the pipe operator (|) to indicate alternative types of the single value that the function returns. To define the same function in Python versions older than 3.10, you can use an alternative syntax:

Python
      
    
from typing import Union

def parse_email(email_address: str) -> Union[str, None]:
    if "@" in email_address:
        username, domain = email_address.split("@")
        return username
    return None

This function uses the Union type from the typing module to indicate that parse_email() returns either a string or None, depending on the input value. Whether you use the old or new syntax, a union type hint can combine more than two data types.

Even when using a modern Python release, you may still prefer the Union type over the pipe operator if your code needs to run in older Python versions.

Note: One challenge with functions that may return different types is that you need to check the return type when you call the function. In the examples above, you need to test whether you got None when parsing the email address.

If the return type can be deduced from the argument types, then you can alternatively use @overload to specify different type signatures.

Now that you know how to define a function that returns a single value of potentially different types, you can turn your attention toward using type hints to declare that a function can return more than one piece of data.

Use Python’s Type Hints for Multiple Pieces of Data of Different Types

Sometimes, a function returns more than one value, and you can communicate this in Python using type hints. You can use a tuple to indicate the types of the individual pieces of data that a function returns at once. In Python 3.9 and later, you can use built-in tuple data structure. On older versions, you need to use typing.Tuple in your annotations.

Now, consider a scenario where you want to build on the previous example. You aim to declare a function whose return value incorporates multiple pieces of data of various types. In addition to returning the username obtained from an email address, you want to update the function to return the domain as well.

Here’s how you’d use type hints to indicate that the function returns a tuple with a string for the username and another string for the domain:

Python
      
    
def parse_email(email_address: str) -> tuple[str, str] | None:
    if "@" in email_address:
        username, domain = email_address.split("@")
        return username, domain
    return None

Read the full article at https://realpython.com/python-type-hints-multiple-types/ »

[ 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 #178: Guiding Scientific Python Library Development

2023-10-27T12:00:00+00:00

How do you prepare a scientific Python project for sharing with others? Could you use some best practices and guidance for packaging, documentation, and testing? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

Boost Your Coding Productivity With Ptpython

2023-10-25T14:00:00+00:00

Ptpython is a feature-rich and user-friendly Python REPL (Read-Eval-Print Loop) that takes your interactive Python coding experience to a whole new level. Unlike the standard Python REPL, ptpython offers a host of powerful features designed to boost productivity and streamline the development process. Its intuitive interface, syntax highlighting, and robust auto-completion capabilities make writing and exploring Python code a breeze.

The interactive shell also provides the built-in ability to inspect Python objects, so you can quickly look up function references and module documentation without leaving the REPL environment. Whether you’re a beginner or an experienced Python programmer, ptpython’s interactive shell and multiline editing support will help you produce quality code.

In this tutorial, you’ll learn how to:

Install and launch ptpython
Initiate basic commands to enhance your coding experience
Use typing completion and code auto-suggestion in your interactive shell
Take advantage of input validation and error handling
Customize the interactive experience to your liking

Once you have a better understanding of the advantages of using this enhanced Python shell, you’ll be on your way to creating a unique shell experience while elevating your Python coding workflow in an interactive environment.

Get Your Cheat Sheet: Click here to download a free cheat sheet that sums up the most useful ptpython settings.

Installing and Launching Ptpython

It’s time to install ptpython in your machine. First, ensure that you have Python installed in your machine. Then, head over to your command line and install ptpython using the pip command. If you want to isolate the ptpython intallation, then you can use a virtual environment. Otherwise, you can install it universally, as you’ll see in this tutorial:

Windows PowerShell
      
PS> python -m pip install ptpython

By hitting the Enter key, you download the library and make it available on your machine. To confirm that the library has been installed, you’ll launch the shell in the next step.

You’re now ready to explore your newly installed tool, which is a feature-rich Python REPL. But first, you have to launch it. While you’re still in your command prompt, enter the following command:

Windows PowerShell

PS> ptpython

You only need this command to launch an interactive session. A new session will begin with the >>> prompt, signaling that the interactive shell is ready to accept your code. Your interface should look something like this:

Despite sharing a lot of similarities with the Python shell, the ptpython interface adds several interesting features. For example, at the bottom of the shell window, you’ll see a menu shortcut. The menu shortcut gives you a glimpse of what you can do within the interactive shell. In later sections, you’ll get to know how the menu system is the control center of ptpython.

Note: The pt part of ptpython refers to Prompt Toolkit which is a library for building interactive command line applications that ptpyton uses under the hood.

If you want to go back to the command line, then you’ll have to exit the interactive shell. There are other shortcuts that you can use to exit ptpython, but for now, you’ll use the exit() command:

Python
      
>>> exit()

The exit() command is the same command that you’d find in the standard Python shell. Once you enter this command in the prompt, you’ll return to the regular command line.

In the next section, you’ll come to understand the intricacies that make ptpython an attractive alternative to the standard Python shell.

Comparing the Standard Python Shell vs Ptpython

The standard Python shell offers a way to interact with Python on your computer without using a code editor or an IDE. However, it can be a rigid tool to work with for beginners. Alternatives like IPython, bpython, and ptpython offer more functionality in the interactive shell.

With ptpython, you can gain an advantage over the standard shell by utilizing the following functionalities, which can power up your coding experience:

Code and syntax highlighting, a functionality that you won’t find in the Python shell
Completion capabilities that go way beyond the Python standard shell’s tab completion and reduce errors in your coding sessions
Input validation to alert you when you’re about to execute erroneous code, in contrast to the Python standard shell’s executing and returning an error
A powerful menu that allows you to access other functionalities
The ability to seamlessly customize the ptpython interface by changing code color and shell behavior

These differences make ptpython a suitable alternative if you want to have a richer and more interactive experience as you code. This powerful interactive shell offers more tools, as you’ll learn in the next section.

Read the full article at https://realpython.com/ptpython-shell/ »

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

Python Basics Exercises: Building Systems With Classes

2023-10-24T14:00:00+00:00

In Python Basics: Building Systems With Classes, you moved beyond the basics of object-oriented programming (OOP), and started to put those classes to work. In this exercise course you will employ these capabilities to build more complex systems and write readable, reusable code.

In this video course, you’ll practice the following:

Compose classes together to create layers of functionality
Inherit and override behavior from other classes to create variations
Creatively mix and match these approaches
Instantiate classes with attributes and methods
Override methods from a parent class

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

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

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

How to Run Your Python Scripts and Code

2023-10-23T14:00:00+00:00

A Python script or program is a file containing executable Python code. Being able to run Python scripts and code is probably the most important skill that you need as a Python developer. By running your code, you’ll know if it works as planned. You’ll also be able to test and debug the code to fix errors and issues. Ultimately, you write code in order to run it and accomplish tasks.

In this tutorial, you’ll learn about some of the techniques for running Python scripts and code. The technique that you’ll use in each situation will depend on your environment, platform, needs, and skills.

In this tutorial, you’ll learn how to:

Run Python scripts from your operating system’s command line or terminal
Execute Python code and scripts in interactive mode using the standard REPL
Use your favorite IDE or code editor to run your Python scripts
Fire up your scripts and programs from your operating system’s file manager

To get the most out of this tutorial, you should know the basics of working with your operating system’s terminal and file manager. It’d also be beneficial for you to be familiar with a Python-friendly IDE or code editor and with the standard Python REPL (Read-Eval-Print Loop).

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

Take the Quiz: Test your knowledge with our interactive “How to Run Your Python Scripts” quiz. Upon completion you will receive a score so you can track your learning progress over time:

Take the Quiz »

What Scripts and Modules Are

In computing, the term script refers to a text file containing a logical sequence of orders that you can run to accomplish a specific task. These orders are typically expressed in a scripting language, which is a programming language that allows you to manipulate, customize, and automate tasks.

Scripting languages are usually interpreted at runtime rather than compiled. So, scripts are typically run by some kind of interpreter, which is responsible for executing each order in a sequence.

Python is an interpreted language. Because of that, Python programs are commonly called scripts. However, this terminology isn’t completely accurate because Python programs can be way more complex than a simple, sequential script.

In general, a file containing executable Python code is called a script—or an entry-point script in more complex applications—which is a common term for a top-level program. On the other hand, a file containing Python code that’s designed to be imported and used from another Python file is called a module.

So, the main difference between a module and a script is that modules store importable code while scripts hold executable code.

Note: Importable code is code that defines something but doesn’t perform a specific action. Some examples include function and class definitions. In contrast, executable code is code that performs specific actions. Some examples include function calls, loops, and conditionals.

In the following sections, you’ll learn how to run Python scripts, programs, and code in general. To kick things off, you’ll start by learning how to run them from your operating system’s command line or terminal.

How to Run Python Scripts From the Command Line

In Python programming, you’ll write programs in plain text files. By convention, files containing Python code use the .py extension, and there’s no distinction between scripts or executable programs and modules. All of them will use the same extension.

Note: On Windows systems, the extension can also be .pyw for those applications that should use the pythonw.exe launcher.

To create a Python script, you can use any Python-friendly code editor or IDE (integrated development environment). To keep moving forward in this tutorial, you’ll need to create a basic script, so fire up your favorite text editor and create a new hello.py file containing the following code:

Python
      
# hello.py

print("Hello, World!")

This is the classic "Hello, World!" program in Python. The executable code consists of a call to the built-in print() function that displays the "Hello, World!" message on your screen.

With this small program ready, you’re ready to learn different ways to run it. You’ll start by running the program from your command line, which is arguably the most commonly used approach to running scripts.

Using the `python` Command

To run Python scripts with the python command, you need to open a command-line window and type in the word python followed by the path to your target script:

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

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

The Real Python Podcast – Episode #177: Welcoming PyPI's Safety & Security Engineer Mike Fiedler

2023-10-20T12:00:00+00:00

You may remember a recent Python Package Index (PyPI) announcement about hiring a full-time security engineer. We've also mentioned several current security initiatives from PyPI. This week on the show, we talk with Mike Fiedler about accepting this new role and securing accounts on PyPI.

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

Python's F-String for String Interpolation and Formatting

2023-10-18T14:00:00+00:00

Python f-strings provide a quick way to interpolate and format strings. They’re readable, concise, and less prone to error than traditional string interpolation and formatting tools, such as the .format() method and the modulo operator (%). An f-string is also a bit faster than those tools!

By the end of this tutorial, you’ll know why f-strings are such a powerful tool that you should learn and master as a Python developer.

In this tutorial, you’ll learn how to:

Interpolate values, objects, and expressions into your strings using f-strings
Format f-strings using Python’s string formatting mini-language
Leverage some cool features of f-strings in Python 3.12 and beyond
Decide when to use traditional interpolation tools instead of f-strings

To get the most out of this tutorial, you should be familiar with Python’s string data type. It’s also be beneficial to have experience with other string interpolation tools like the modulo operator (%) and the .format() method.

Get Your Code: Click here to download the free sample code that shows you how to do string interpolation and formatting with Python’s f-strings.

Interpolating and Formatting Strings Before Python 3.6

Before Python 3.6, you had two main tools for interpolating values, variables, and expressions inside string literals:

The string interpolation operator (%), or modulo operator
The str.format() method

You’ll get a refresher on these two string interpolation tools in the following sections. You’ll also learn about the string formatting capabilities that these tools offer in Python.

The Modulo Operator, `%`

The modulo operator (%) was the first tool for string interpolation and formatting in Python and has been in the language since the beginning. Here’s what using this operator looks like in practice:

Python
      
>>> name = "Jane"

>>> "Hello, %s!" % name
'Hello, Jane!'

In this quick example, you use the % operator to interpolate the value of your name variable into a string literal. The interpolation operator takes two operands:

A string literal containing one or more conversion specifiers
The object or objects that you’re interpolating into the string literal

The conversion specifiers work as replacement fields. In the above example, you use the %s combination of characters as a conversion specifier. The % symbol marks the start of the specifier, while the s letter is the conversion type and tells the operator that you want to convert the input object into a string.

If you want to insert more than one object into your target string, then you can use a tuple. Note that the number of objects in the tuple must match the number of format specifiers in the string:

Python
      
>>> name = "Jane"
>>> age = 25

>>> "Hello, %s! You're %s years old." % (name, age)
'Hello, Jane! You're 25 years old.'

In this example, you use a tuple of values as the right-hand operand to %. Note that you’ve used a string and an integer. Because you use the %s specifier, Python converts both objects to strings.

You can also use dictionaries as the right-hand operand in your interpolation expressions. To do this, you need to create conversion specifiers that enclose key names in parentheses:

Python
      
>>> "Hello, %(name)s! You're %(age)s years old." % {"name": "Jane", "age": 25}
"Hello, Jane! You're 25 years old."

This syntax provides a readable approach to string interpolation with the % operator. You can use descriptive key names instead of relying on the positional order of values.

When you use the % operator for string interpolation, you can use conversion specifiers. They provide some string formatting capabilities that take advantage of conversion types, conversion flags, and some characters like the period (.) and the asterisk (*). Consider the following example:

Python
      
>>> "Balance: $%.2f" % 5425.9292
'Balance: $5425.93'

>>> print("Name: %s\nAge: %5s" % ("John", 35))
Name: John
Age:    35

In the first example, you use the %.2f conversion specifier to represent currency values. The f letter tells the operator to convert to a floating-point number. The .2 part defines the precision to use when converting the input. In the second example, you use %5s to align the age value five positions to the right.

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

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

Python Basics Exercises: Object-Oriented Programming

2023-10-17T14:00:00+00:00

In Python Basics: Object-Oriented Programming, you learned how OOP, or object-oriented programming, is a method of structuring a program by bundling related properties and behaviors into individual objects.

In this video course, you’ll practice the following:

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

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 a Blog From Scratch With Django

2023-10-16T14:00:00+00:00

There are plenty of blogging platforms out there that you can use out of the box. However, building your own blog from scratch with Django is a great way to keep control over your content. Even if you’re just getting started with Django, its user-friendly features will allow you to focus on designing and posting your content.

In this tutorial, you’ll learn how to:

Set up a new Django project
Create and edit blog posts
Display posts to the user
Assign categories to posts
Allow users to comment on posts

Along the way, you’ll leverage the Django admin site and explore how to work with forms in Django. This is an ideal project to dip your toes into the world of Django, but you should have a solid foundation in Python basics.

At the end of this tutorial, you’ll be able to share your knowledge through a working blog that you’ve built from scratch. If you’re curious about how the final source code looks, then you can click the link below:

Get Your Code: Click here to download your free source code to build a blog from scratch with Django.

Set Up the Development Environment

Whenever you’re starting a new web development project, it’s a good idea to first set up your development environment. Create a new directory for your project to live in, and cd into it:

Shell
      
$ mkdir django-blog
$ cd django-blog

Once you’re inside the django-blog/ directory, it’s a good idea to create a virtual environment to manage dependencies. Select your operating system below and use your platform-specific command to set up a virtual environment:

Windows PowerShell
      
PS> python -m venv venv

Shell
      
$ python -m venv venv

This command will create a venv/ folder in your working directory. Inside this directory, you’ll find several files, including a copy of the Python standard library. Later, when you install new dependencies, this directory will store them too. Next, you need to activate the virtual environment by running the following command:

Windows PowerShell
      
PS> .\venv\Scripts\activate
(venv) PS>

Shell
      
$ source venv/bin/activate
(venv) $

With the above commands, you create and activate a virtual environment named venv by using Python’s built-in venv module. The parenthetical (venv) in front of the prompt indicates that you’ve successfully activated the virtual environment.

Now that you’ve created and activated a virtual environment, it’s time to install Django. You can do this using pip:

Shell
      
(venv) $ python -m pip install Django

Once you’ve set up the virtual environment and installed Django, you can now dive into creating your Django project.

Start Your Django Project

A Django web application is made up of a project and apps. A Django project holds some configurations that apply to the web application as a whole, such as project settings, URLs, shared templates, and static files. Each Django app can have its own URLs as well as its own HTML templates and static files, such as JavaScript and CSS.

To create your Django project, make sure you’re in the django-blog/ directory with your virtual environment activated. Then, run the following command to create the personal_blog project:

Shell
      
(venv) $ django-admin startproject personal_blog .

Don’t forget to add the dot (.) at the end of the command above. The dot prevents Django from creating a nested project directory for your portfolio project. Otherwise you’d end up with a personal_blog/ folder that contains a personal_blog/ subdirectory.

By running the startproject command as shown above, you’ve told Django to create one personal_blog/ folder in the django-blog/ directory. Your directory structure should look something like this:

Read the full article at https://realpython.com/build-a-blog-from-scratch-django/ »

[ 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 #176: Building Python Best Practices and Fundamental Skills

2023-10-13T12:00:00+00:00

What fundamental developer skills are new Python users missing? What best practices might developers without a computer science background be lacking? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

How to Sort Unicode Strings Alphabetically in Python

2023-10-11T14:00:00+00:00

Sorting strings in Python is something that you can almost take for granted if you do it all the time. Yet, it can become surprisingly tricky considering all the edge cases lurking in the vast Unicode standard. Understanding Unicode isn’t an easy feat, so prepare yourself for a whirlwind tour of surprising edge cases and effective ways of dealing with them.

Note: In this tutorial, you’ll often use the term Unicode string to mean any string with non-Latin letters and characters like emoji. However, strings consisting of Basic Latin letters also fall into this category because the underlying ASCII table is a subset of Unicode.

Python pioneered and popularized a robust sorting algorithm called Timsort, which now ships with several major programming languages, including Java, Rust, and Swift. When you call sorted() or list.sort(), Python uses this algorithm under the surface to rearrange elements. As long as your sequence contains comparable elements of compatible types, then you can sort numbers, strings, and other data types in the expected order:

Python
      
        
      
    
>>> math_constants = [6.28, 2.72, 3.14]
>>> sorted(math_constants)
[2.72, 3.14, 6.28]

>>> fruits = ["orange", "banana", "lemon", "apple"]
>>> sorted(fruits)
['apple', 'banana', 'lemon', 'orange']

>>> people = [("John", "Doe"), ("Anna", "Smith")]
>>> sorted(people)
[('Anna', 'Smith'), ('John', 'Doe')]

Unless you specify otherwise, Python sorts these elements by value in ascending order, comparing them pairwise. Each pair must contain elements that are comparable using either the less than (<) or greater than (>) operator. Sometimes, these comparison operators are undefined for specific data types like complex numbers or between two distinct types. In these cases, a comparison will fail:

Python
      
        
      
    
>>> 4 + 2j < 2 + 4j
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'complex' and 'complex'

>>> 3.14 < "orange"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'float' and 'str'

In most cases, you’ll be working with homogeneous sequences comprising elements of the same type, so you’ll rarely run into this problem in the wild. However, things may start to fall apart once you throw strings with non-Latin characters into the mix, such as letters with diacritics or accents:

Python
      
>>> polish_names = ["Zbigniew", "Ludmiła", "Żaneta", "Łukasz"]
>>> sorted(polish_names)
['Ludmiła', 'Zbigniew', 'Łukasz', 'Żaneta']

In this example, you run into a common challenge associated with sorting strings. When a string contains characters whose ordinal values extend beyond the usual ASCII range, then you might get unexpected results like what you have here. The name Łukasz ends up after Zbigniew, even though the letter Ł (pronounced like a w sound in English) occurs earlier than Z in the Polish alphabet. Why’s that?

Python sorts strings lexicographically by comparing Unicode code points of the individual characters from left to right. It just so happens that the letter Ł has a higher ordinal value in Unicode than the letter Z, making it greater than any of the Latin letters:

Python
      
>>> ord("Ł")
321

>>> ord("Z")
90

>>> any("Ł" < letter for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
False

Code points are unique yet arbitrary identifiers of Unicode characters, and they don’t inherently agree with the alphabetical order of spoken languages. So, lexicographic sorting won’t be appropriate for languages other than English.

Different cultures follow different rules for sorting strings, even when they share the same alphabet or parts of it with other cultures. For example, the ch digraph is considered two separate letters (c and h) in Polish, but it becomes a stand-alone letter placed between h and i in the Czech alphabet. This is known as a contraction in Unicode.

Note: Language rules occasionally change. For instance, the Spanish alphabet treated the ch and ll digraphs as single letters until 1994, when the official language regulation institution, RAE, declared them separate.

At some point, the accent ordering in French changed from backward to forward everywhere in the world except for Canada, which still sticks to the old tradition:

	Accent Ordering
France	cote, coté, côte, côté
Canada	cote, côte, coté, côté

In modern French, words are compared from left to right. The earliest letter with an accent, which is ô in the example above, corresponds to a greater sort key, pushing the word to the end of the list. On the other hand, in Canada, words are compared backward from right to left, so the last accent’s position determines the final order.

Depending on their geographic location worldwide, individuals speaking the same language may expect a slightly different sorting order.

Moreover, the sorting order can sometimes differ within the same culture, depending on the context. For example, most German phone books tend to treat letters with an umlaut (ä, ö, ü) similarly to the ae, oe, and ue letter combinations. However, other countries overwhelmingly treat these letters the same as their Latin counterparts (a, o, u).

There’s no universally correct way to sort Unicode strings. You need to tell Python which rules to apply to get the desired ordering. So, how do you sort Unicode strings alphabetically in Python?

Get Your Code: Click here to download the free sample code that shows you how to sort Unicode strings alphabetically with Python.

How to Sort Strings Using the Unicode Collation Algorithm (UCA)

The problem of sorting Unicode strings isn’t unique to Python. It’s a common challenge in any programming language or database. To address it, Technical Report #10 in the Unicode Technical Standard (UTS) describes the collation of Unicode strings, which is a consistent way of comparing two strings to establish their sorting order.

The Unicode Collation Algorithm (UCA) assigns a hierarchy of numeric weights to each character, allowing the creation of binary sort keys that account for accents and other special cases. These keys are defined at four levels that determine various features of a character:

Primary: The base letter
Secondary: The accents
Tertiary: The letter case
Quaternary: Other features

Later in this tutorial, you’ll learn how to leverage these weight levels to customize the Unicode collation algorithm by, for example, ignoring the letter case in case-insensitive sorting.

Note: This hierarchical nature of character weights allows you to compare sort keys incrementally to increase performance. It also helps conserve memory. For example, some implementations of the UCA take advantage of the trie data structure to efficiently store and retrieve the weights for a given string.

While the UCA supplies the Default Unicode Collation Element Table (DUCET), you should generally customize this default collation table to the specific needs of a particular language and application. It’s virtually impossible to ensure the desired sort order for all languages using only one character table. Therefore, software libraries implementing the UCA usually rely on the Common Locale Data Repository (CLDR) to provide such customization.

This repository contains several XML documents with language-specific information. For example, the collation rules for sorting text in Polish explain the relationship between the letters z, ź, and ż in both uppercase and lowercase:

Read the full article at https://realpython.com/python-sort-unicode-strings/ »

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

Using Python's min() and max()

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

Python’s built-in min() and max() functions come in handy when you need to find the smallest and largest values in an iterable or in a series of regular arguments. Even though these might seem like fairly basic computations, they turn out to have many interesting use cases in real-world programing. You’ll try out some of those use cases here.

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

Use Python’s min() and max() to find smallest and largest values in your data
Call min() and max() with a single iterable or with any number of regular arguments
Use min() and max() with strings and dictionaries
Tweak the behavior of min() and max() with the key and default arguments
Use comprehensions and generator expressions as arguments to min() and max()

Once you have this knowledge under your belt, then you’ll be prepared to write a bunch of practical examples that will showcase the usefulness of min() and max(). Finally, you’ll code your own versions of min() and max() in pure Python, which can help you understand how these functions work internally.

To get the most out of this video course, you should have some previous knowledge of Python programming, including topics like for loops, functions, list comprehensions, and generator expressions.

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

2023-10-09T14:00:00+00:00

As the leaves turned yellow and fall set in, the Python community prepared for the release of Python 3.12 in early October. This new version of the most popular programming language brings several exciting new features, including better error messages and improvements to static typing. It also lays the groundwork for enhanced parallelism.

Microsoft Excel is about to become a friendlier space for Pythonistas with the integration of the Python Editor, opening up new possibilities for those bridging the gap between coding and data analysis.

September also saw the release of the Mojo Software Development Kit (SDK) for Linux by Modular. As a superset of Python, Mojo has been the talk of the town, offering features such as familiar syntax, Python interoperability, and unrivaled performance.

Web developers weren’t left behind, with the availability of Django 5.0 alpha 1 revealing some promising enhancements. The Django community also got a chance to express their thoughts through the Django Developers Survey 2023.

Part of what makes Python’s growth successful is the amount of thought that goes into every change. This thoughful approach was on display in the rejection of PEP 713, the proposal to include callable modules in Python 3.12.

Let’s plunge into the most exciting Python news from September 2023!

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

Python 3.12 Arrives in October 2023

Although this article covers the major events of September, you’re reading it at a time when Python 3.12 has already been released. Because it’s such a big and long-awaited event in the Python community, we’ve decided to include it in this roundup.

Every year in early October, a new version of Python gets released, and 2023 was no exception. Python 3.12 arrived with a range of features and improvements. While they predominantly enhance the interpreter’s internal workings, the new release still brings a few tangible benefits to the table.

The key new features in Python 3.12 that most developers will be excited about include:

In addition to these, you can expect to see various performance optimizations and several improvements to standard library modules, as well as many deprecations and removals that have been planned for a long time.

If you’re interested in reading a more detailed summary of the changes, then check out What’s New In Python 3.12 and the official Python 3.12 changelog.

You can also stay right here on the Real Python website and immerse yourself in the ultimate Python 3.12 experience by diving into one or all of the following resources:

Tutorial: Learn about the cool new features in Python 3.12 through hands-on examples that you can follow in a step-by-step fashion.
Video Course: Enjoy the companion video course that explores the new features in Python 3.12 in a more interactive and visual way.
Podcast: Grab your favorite beverage, make yourself comfortable, and listen to our industry experts talk about the exciting updates and enhancements in Python 3.12.

Want more? Consider joining the discussion on the Real Python Community chat, where you can ask questions, share insights, and connect with other Python enthusiasts eager to learn about Python 3.12. You can also learn from those who have already been using the Python 3.12 pre-release versions.

If you prefer a live Q&A session with screen sharing, then we invite you to drop by a virtual Office Hours session hosted weekly by our team members. It’s a great opportunity to hang out with experts from the Python community and fellow Pythonistas like you. While there’s no fixed agenda, you can always ask questions specific to Python 3.12 or remain a silent participant by simply observing and learning from the discussions.

As with every new release, upgrading to the latest Python version right away might not be feasible or desirable, especially for businesses where stability and backward compatibility are crucial. It usually takes time for library vendors to catch up. That said, a few notable libraries, including NumPy and pandas, already rolled out Python wheels targeting Python 3.12 on PyPI back in September.

Are you ready to take the leap into Python 3.12 yet?

Microsoft Excel Gets the Python Editor

Following the recent news from Microsoft and Anaconda about their partnership to bring Python into Excel, they don’t seem to be slowing down. Just this month, the Excel team at Microsoft announced the introduction of an experimental code editor for Python. While it’s only available as an extension at the moment, the editor may eventually become an integral part of the popular spreadsheet software.

Today, you can enable the Python Editor by installing the Excel Labs add-in, which is a Microsoft Garage project that started earlier this year to collect user feedback about experimental features in Excel. Primarily, this add-in provides an advanced formula-editing interface featuring syntax highlighting, auto-completion, inline error reporting, and more. Now, it also comes with a dedicated Python editor:

Thanks to being built on top of the open-source Monaco Editor, which is also a core component of the familiar Visual Studio Code, the Python Editor can run in your web browser. That’s essential for the ability to use the editor in the cloud-based Microsoft 365 office suite.

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

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

The Real Python Podcast – Episode #175: Exploring the New Features of Python 3.12

2023-10-06T12:00:00+00:00

Python 3.12 is here! Our regular guests, Geir Arne Hjelle and Christopher Trudeau, return to discuss the new version. Geir Arne coordinated a series of preview articles with several members of the Real Python team this year, and his showcase tutorial, "Python 3.12: Cool New Features for You to Try," came out on October 2. Christopher's video course was posted the next day, covering the topics from the article with visual examples of Python 3.12 in action.

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

Python's tuple Data Type: A Deep Dive With Examples

2023-10-04T14:00:00+00:00

In Python, a tuple is a built-in data type that allows you to create immutable sequences of values. The values or items in a tuple can be of any type. This makes tuples pretty useful in those situations where you need to store heterogeneous data, like that in a database record, for example.

Through this tutorial, you’ll dive deep into Python tuples and get a solid understanding of their key features and use cases. This knowledge will allow you to write more efficient and reliable code by taking advantage of tuples.

In this tutorial, you’ll learn how to:

Create tuples in Python
Access the items in an existing tuple
Unpack, return, copy, and concatenate tuples
Reverse, sort, and traverse existing tuples
Explore other features and common gotchas of tuples

In addition, you’ll explore some alternative tools that you can use to replace tuples and make your code more readable and explicit.

To get the most out of this tutorial, you should have a good understanding of a few Python concepts, including variables, functions, and for loops. Familiarity with other built-in data structures, especially lists, is also a plus.

Get Your Code: Click here to download the free sample code that shows you how to write more readable code with tuples in Python.

Getting Started With Python’s `tuple` Data Type

The built-in tuple data type is probably the most elementary sequence available in Python. Tuples are immutable and can store a fixed number of items. For example, you can use tuples to represent Cartesian coordinates (x, y), RGB colors (red, green, blue), records in a database table (name, age, job), and many other sequences of values.

In all these use cases, the number of elements in the underlying tuple is fixed, and the items are unchangeable. You may find several situations where these two characteristics are desirable. For example, consider the RGB color example:

Python
      
>>> red = (255, 0, 0)

Once you’ve defined red, then you won’t need to add or change any components. Why? If you change the value of one component, then you won’t have a pure red color anymore, and your variable name will be misleading. If you add a new component, then your color won’t be an RGB color. So, tuples are perfect for representing this type of object.

Note: Throughout this tutorial, you’ll find the terms items, elements, and values used interchangeably to refer to the objects stored in a tuple.

Some of the most relevant characteristics of tuple objects include the following:

Ordered: They contain elements that are sequentially arranged according to their specific insertion order.
Lightweight: They consume relatively small amounts of memory compared to other sequences like lists.
Indexable through a zero-based index: They allow you to access their elements by integer indices that start from zero.
Immutable: They don’t support in-place mutations or changes to their contained elements. They don’t support growing or shrinking operations.
Heterogeneous: They can store objects of different data types and domains, including mutable objects.
Nestable: They can contain other tuples, so you can have tuples of tuples.
Iterable: They support iteration, so you can traverse them using a loop or comprehension while you perform operations with each of their elements.
Sliceable: They support slicing operations, meaning that you can extract a series of elements from a tuple.
Combinable: They support concatenation operations, so you can combine two or more tuples using the concatenation operators, which creates a new tuple.
Hashable: They can work as keys in dictionaries when all the tuple items are immutable.

Tuples are sequences of objects. They’re commonly called containers or collections because a single tuple can contain or collect an arbitrary number of other objects.

Note: In Python, tuples support several operations that are common to other sequence types, such as lists, strings, and ranges. These operations are known as common sequence operations. Throughout this tutorial, you’ll learn about several operations that fall into this category.

In Python, tuples are ordered, which means that they keep their elements in the original insertion order:

Python
      
>>> record = ("John", 35, "Python Developer")

>>> record
('John', 35, 'Python Developer')

The items in this tuple are objects of different data types representing a record of data from a database table. If you access the tuple object, then you’ll see that the data items keep the same original insertion order. This order remains unchanged during the tuple’s lifetime.

You can access individual objects in a tuple by position, or index. These indices start from zero:

Python
      
        
      
    
>>> record[0]
'John'
>>> record[1]
35
>>> record[2]
'Python Developer'

Positions are numbered from zero to the length of the tuple minus one. The element at index 0 is the first element in the tuple, the element at index 1 is the second, and so on.

Cool! You’ve had a first glance at tuples. It’s time to dive deeper into all of the above characteristics of tuples and more. To kick things off, you’ll start by learning the different ways to create tuples in Python.

Constructing Tuples in Python

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

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

What's New in Python 3.12

2023-10-03T14:00:00+00:00

It’s that time of year again, time for a new release of Python. Although Python 3.12 mostly focuses on internal improvements, there’s a little something for everyone. You can read up on all the new features by checking out the changelog.

In this video course, you’ll learn about the following changes:

Improvements to f-strings
More did-you-mean error messages
New features in the standard library
Additions to static typing
Changes to the CPython interpreter

In this video course, you’ll explore these changes and see how this new version of Python can work for you.

If you want to try any of the examples in this video course, then you’ll need to use Python 3.12. 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.

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

2023-10-02T14:00:00+00:00

Python 3.12 was published on October 2, 2023. As usual, the new version comes out in October after lots of effort by volunteers worldwide.

The new version comes with several new features and improvements that you’ll explore in this tutorial. You can also dive into the documentation to see a complete list of all changes.

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

Better error messages with helpful suggestions and guidance
More expressive f-strings that are backed by Python’s PEG parser
Optimizations, including inlined comprehensions, for a faster Python
A new syntax for type variables that you use to annotate generics
Support for the powerful perf profiler on Linux

If you want to try any of the examples in this tutorial, then you’ll need to use Python 3.12. The tutorials 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.12:

Free Bonus: Click here to download your sample code for a sneak peek at Python 3.12, coming in October 2023.

Improved Error Messages

Python is usually recognized as a good beginner language, and it’s lauded for its readable syntax. One area where it’s become even more user-friendly lately is error messages.

In Python 3.10, many error messages—especially for syntax errors—got more informative and precise. Similarly, Python 3.11 added more information in tracebacks, making it more convenient to pinpoint offending code.

The latest version of Python continues the work of improving your developer experience by providing better error messages. In particular, several common error messages now come with helpful suggestions. In the rest of this section, you’ll explore the new and improved messages.

Several of the improvements relate to importing modules. In the next three examples, you try to work with π by importing pi from math. In each example, you’ll see one of the new suggestions in Python 3.12. Here’s the first one:

Python
      
>>> math.pi
Traceback (most recent call last):
  ...
NameError: name 'math' is not defined. Did you forget to import 'math'?

When you use math without importing it first, you’ll get a traditional NameError. Additionally, the parser helpfully reminds you that you need to import math before accessing it.

The reminder about remembering to import modules only triggers for standard library modules. For these error messages, Python 3.12 doesn’t track third-party packages that you’ve installed.

It’s possible to import specific names from a module using a from-import statement. If you happen to switch the order of the keywords, you’ll now get a friendly nudge towards the correct syntax:

Python
      
        
      
    
>>> import pi from math
  ...
    import pi from math
    ^^^^^^^^^^^^^^^^^^^
SyntaxError: Did you mean to use 'from ... import ...' instead?

Here, you tried to import pi from math, but Python needs you to reorder the statement and put from before import.

To see a third new error message, check out what happens if you import py and not pi from math:

Python
      
>>> from math import py
Traceback (most recent call last):
  ...
ImportError: cannot import name 'py' from 'math'. Did you mean: 'pi'?

There’s no py name in math, so you get an ImportError. The parser suggests that you probably meant pi instead of py. Python 3.10 introduced a similar suggestion feature, where Python looks for similar names. What’s new in Python 3.12 is the ability to do this while importing.

In addition to these three improvements related to imports, there’s a final improvement concerning methods defined inside classes. Have a look at the following implementation of a Circle class:

Python
      
    
# shapes.py

from math import pi

class Circle:
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return pi * radius**2

Note that you wrongly refer to radius instead of self.radius inside .area(). This will cause an error when you call the method:

Python
      
        
      
    
>>> from shapes import Circle
>>> Circle(5).area()
Traceback (most recent call last):
  ...
  File "/home/realpython/shapes.py", line 10, in area
    return pi * radius**2
                    ^^^^^^
NameError: name 'radius' is not defined. Did you mean: 'self.radius'?

Read the full article at https://realpython.com/python312-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 #174: Considering ChatGPT's Technical Review of a Programming Book

2023-09-29T12:00:00+00:00

What can you learn from feeding an entire book on Python programming into ChatGPT-4 and asking it to provide a technical review? What are the potential pitfalls of using an LLM as a learning tool? This week on the show, author Al Sweigart talks about his recent experiments using ChatGPT and 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 3.12 Preview: Static Typing Improvements

2023-09-27T14:00:00+00:00

Python’s support for static typing gradually improves with each new release of Python. The core features were in place in Python 3.5. Since then, there’ve been many tweaks and improvements to the type hinting system. This evolution continues in Python 3.12, which, in particular, simplifies the typing of generics.

In this tutorial, you’ll:

Use type variables in Python to annotate generic classes and functions
Explore the new syntax for type hinting type variables
Model inheritance with the new @override decorator
Annotate **kwargs more precisely with typed dictionaries

This won’t be an introduction to using type hints in Python. If you want to review the background that you’ll need for this tutorial, then have a look at Python Type Checking.

You’ll find many other new features, improvements, and optimizations in Python 3.12. The most relevant ones include the following:

Go ahead and check out what’s new in the changelog for more details on these and other features or listen to our comprehensive podcast episode.

Free Bonus: Click here to download your sample code for a sneak peek at Python 3.12, coming in October 2023.

Recap Type Variable Syntax Before Python 3.12

Type variables have been a part of Python’s static typing system since its introduction in Python 3.5. PEP 484 introduced type hints to the language, and type variables and generics play an important role in that document. In this section, you’ll dive into how you’ve used type variables so far. This’ll give you the necessary background to appreciate the new syntax that you’ll learn about later.

A generic type is a type parametrized by another type. Typical examples include a list of integers and a tuple consisting of a float, a string, and another float. You use square brackets to parametrize generics in Python. You can write the two examples above as list[int] and tuple[float, str, float], respectively.

In addition to using built-in generic types, you can define your own generic classes. In the following example, you implement a generic queue based on deque in the standard library:

Python
      
    
# generic_queue.py

from collections import deque
from typing import Generic, TypeVar

T = TypeVar("T")

class Queue(Generic[T]):
    def __init__(self) -> None:
        self.elements: deque[T] = deque()

    def push(self, element: T) -> None:
        self.elements.append(element)

    def pop(self) -> T:
        return self.elements.popleft()

This is a first-in, first-out (FIFO) queue. It represents the kind of lines that you’ll find yourself in at stores, where the first person into the queue is also the first one to leave the queue. Before looking closer at the code, and in particular at the type hints, play a little with the class:

Python
      
>>> from generic_queue import Queue

>>> queue = Queue[int]()

>>> queue.push(3)
>>> queue.push(12)
>>> queue.elements
deque([3, 12])

>>> queue.pop()
3

You can use .push() to add elements to the queue and .pop() to remove elements from the queue. Note that when you called the Queue() constructor, you included [int]. This isn’t necessary, but it tells the type checker that you expect the queue to only contain integer elements.

Normally, using square brackets like you did in Queue[int]() isn’t valid Python syntax. You can use square brackets with Queue, however, because you defined Queue as a generic class by inheriting from Generic. How does the rest of your class use this int parameter?

To answer that question, you need to look at T, which is a type variable. A type variable is a special variable that can stand in for any type. However, during type checking, the type of T will be fixed.

In your Queue[int] example, T will be int in all annotations on the class. You could also instantiate Queue[str], where T would represent str everywhere. This would then be a queue with string elements.

If you look back at the source code of Queue, then you’ll see that .pop() returns an object of type T. In your special integer queue, the static type checker will make sure that .pop() returns an integer.

Speaking of static type checkers, how do you actually check the types in your code? Type annotations are mostly ignored during runtime. Instead, you need to install a separate type checker and run it explicitly on your code.

Note: In this tutorial, you’ll use Pyright as your type checker. You can install Pyright from PyPI using pip:

Shell
      
$ python -m pip install pyright

If you’re using Visual Studio Code, then you can use Pyright inside the editor through the Pylance extension. You may need to activate it by setting the Python › Analysis: Type Checking Mode option in your settings.

If you install Pyright, then you can use it to type check your code:

Shell
      
$ pyright generic_queue.py
0 errors, 0 warnings, 0 informations

To see an example of the kinds of errors that Pyright can detect, add the following lines to your generic queue implementation:

Read the full article at https://realpython.com/python312-typing/ »

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

Python Basics Exercises: Conditional Logic and Control Flow

2023-09-26T14:00:00+00:00

In Python Basics: Conditional Logic and Control Flow, you learned that much of the Python code you’ll write is unconditional. That is, the code doesn’t 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 revisit 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 video course, you’ll use the following:

Boolean comparators: ==, !=, <, >, <=, >=
Logical operators: and, or, not
Conditional logic: if … elif … else
Exception handling: try … except
Loops: for, while
Control flow statements: break, continue

Ultimately, you’ll bring all of your knowledge together to build a text-based role-playing game. Along the way, you’ll also get some insight into how to tackle coding challenges in general, which can be a great way to level up as a developer.

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

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 #173: Getting Involved in Open Source & Generating QR Codes With Python

2023-09-22T12:00:00+00:00

Have you thought about contributing to an open-source Python project? What are possible entry points for intermediate developers? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

Design and Guidance: Object-Oriented Programming in Python

2023-09-19T14:00:00+00:00

Writing good object-oriented code is about more than just how to write the syntax. Knowing when and when not to use it, as well as guiding principles behind object-oriented design will help you write better code.

In this course, you’ll learn about:

The objected-oriented approach in Python vs other languages
Cases in which you shouldn’t use classes in Python
Alternatives to inheritance in structuring your code
The SOLID principles for improving your code

SOLID is an acronym for five principles that you should use when thinking about object-oriented code. The principles are:

The Single-Responsibility Principle (SRP)
The Open-Closed Principle (OCP)
The Liskov Substitution Principle (LSP)
The Interface Segregation Principle (ISP)
The Dependency Inversion Principle (DIP)

This course is the third in a three-part series. Part one is an introduction to class syntax, where you learn how to write a class and use its attributes and methods. Part two is about inheritance and class internals.

[ 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 #172: Measuring Multiple Facets of Python Performance With Scalene

2023-09-15T12:00:00+00:00

When choosing a tool for profiling Python code performance, should it focus on the CPU, GPU, memory, or individual lines of code? What if it looked at all those factors and didn't alter code performance while measuring it? This week on the show, we talk about Scalene with Emery Berger, Professor of Computer Science at the University of Massachusetts Amherst.

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

Inheritance and Internals: Object-Oriented Programming in Python

2023-09-12T14:00:00+00:00

Python includes mechanisms for writing object-oriented code where the data and operations on that data are structured together. The class keyword is how you create these structures in Python. The definition of a class can be based on other classes, allowing the creation of hierarchical structures and promoting code reuse. This mechanism is known as inheritance.

In this course, you’ll learn about:

Basic class inheritance
Multi-level inheritance, or classes that inherit from classes
Classes that inherit directly from more than one class, or multiple inheritance
Special methods that you can use when writing classes
Abstract base classes for classes that you don’t want to fully implement yet

This course is the second in a three-part series. Part one is an introduction to class syntax, teaching you how to write a class and use its attributes and methods. Part three dives deeper into the philosophy behind writing good object-oriented 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 #171: Making Each Line of Code Efficient & Python In Excel

2023-09-08T12:00:00+00:00

Are you writing efficient Python with as few lines of code as possible? Are you familiar with the many built-in language features that will simplify your code and make it more Pythonic? Christopher Trudeau is back on the show this week, bringing another batch of PyCoder's Weekly articles and projects.

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

Class Concepts: Object-Oriented Programming in Python

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

Python includes mechanisms for doing object-oriented programming, where the data and operations on that data are structured together. The class keyword is how you create these structures in Python. Attributes are the data values, and methods are the function-like operations that you can perform on classes. In this course, you’ll explore writing code using class and its associated attributes and methods.

In this video course, you’ll learn about:

Why you write object-oriented code
How to write a class
What attributes and methods are
How to use the descriptor protocol

This course is the first in a three-part series. Part two covers how to write reusable hierarchies of classes using inheritance, while part three dives deeper into the philosophy behind writing good object-oriented code.

Download

Sample Code (.zip)

5.2 KB

Download

Course Slides (.pdf)

1013.9 KB

[ 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 #170: Finding the Right Coding Font for Programming in Python

2023-09-01T12:00:00+00:00

What should you consider when picking a font for coding in Python? What characters and their respective glyphs should you check before making your decision? This week on the show, we talk with Real Python author and core team member Philipp Acsany about his recent article, Choosing the Best Coding Font for Programming.

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

Create a Python Wordle Clone With Rich

2023-08-29T14:00:00+00:00

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

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

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

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

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

[ 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 #169: Improving Classification Models With XGBoost

2023-08-25T12:00:00+00:00

How can you improve a classification model while avoiding overfitting? Once you have a model, what tools can you use to explain it to others? This week on the show, we talk with author and Python trainer Matt Harrison about his new book Effective XGBoost: Tuning, Understanding, and Deploying Classification Models.

[ 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

Using the bpython Enhanced REPL

How to Use Type Hints for Multiple Return Types in Python

Use Python’s Type Hints for One Piece of Data of Alternative Types

Use Python’s Type Hints for Multiple Pieces of Data of Different Types

The Real Python Podcast – Episode #178: Guiding Scientific Python Library Development

Boost Your Coding Productivity With Ptpython

Installing and Launching Ptpython

Comparing the Standard Python Shell vs Ptpython

Python Basics Exercises: Building Systems With Classes

How to Run Your Python Scripts and Code

What Scripts and Modules Are

How to Run Python Scripts From the Command Line

Using the python Command

The Real Python Podcast – Episode #177: Welcoming PyPI's Safety & Security Engineer Mike Fiedler

Python's F-String for String Interpolation and Formatting

Interpolating and Formatting Strings Before Python 3.6

The Modulo Operator, %

Python Basics Exercises: Object-Oriented Programming

Build a Blog From Scratch With Django

Set Up the Development Environment

Start Your Django Project

The Real Python Podcast – Episode #176: Building Python Best Practices and Fundamental Skills

How to Sort Unicode Strings Alphabetically in Python

How to Sort Strings Using the Unicode Collation Algorithm (UCA)

Using Python's min() and max()

Python News: What's New From September 2023

Python 3.12 Arrives in October 2023

Microsoft Excel Gets the Python Editor

The Real Python Podcast – Episode #175: Exploring the New Features of Python 3.12

Python's tuple Data Type: A Deep Dive With Examples

Getting Started With Python’s tuple Data Type

Constructing Tuples in Python

What's New in Python 3.12

Python 3.12: Cool New Features for You to Try

Improved Error Messages

The Real Python Podcast – Episode #174: Considering ChatGPT's Technical Review of a Programming Book

Python 3.12 Preview: Static Typing Improvements

Recap Type Variable Syntax Before Python 3.12

Python Basics Exercises: Conditional Logic and Control Flow

The Real Python Podcast – Episode #173: Getting Involved in Open Source & Generating QR Codes With Python

Design and Guidance: Object-Oriented Programming in Python

The Real Python Podcast – Episode #172: Measuring Multiple Facets of Python Performance With Scalene

Inheritance and Internals: Object-Oriented Programming in Python

The Real Python Podcast – Episode #171: Making Each Line of Code Efficient & Python In Excel

Class Concepts: Object-Oriented Programming in Python

The Real Python Podcast – Episode #170: Finding the Right Coding Font for Programming in Python

Create a Python Wordle Clone With Rich

The Real Python Podcast – Episode #169: Improving Classification Models With XGBoost

Using the `python` Command

The Modulo Operator, `%`

Getting Started With Python’s `tuple` Data Type