Real Python

Improve Your Tests With the Python Mock Object Library

2020-05-12T14:00:00+00:00

When you’re writing robust code, tests are essential for verifying that your application logic is correct, reliable, and efficient. However, the value of your tests depends on how well they demonstrate these criteria. Obstacles such as complex logic and unpredictable dependencies make writing valuable tests difficult. The Python mock object library, unittest.mock, can help you overcome these obstacles.

By the end of this course, you’ll be able to:

Create Python mock objects using Mock
Assert that you’re using objects as you intended
Inspect usage data stored on your Python mocks
Configure certain aspects of your Python mock objects
Substitute your mocks for real objects using patch()
Avoid common problems inherent in Python mocking

You’ll begin by seeing what mocking is and how it will improve your tests!

[ 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 eval(): Evaluate Expressions Dynamically

2020-05-11T14:00:00+00:00

Python’s eval() allows you to evaluate arbitrary Python expressions from a string-based or compiled-code-based input. This function can be handy when you’re trying to dynamically evaluate Python expressions from any input that comes as a string or a compiled code object.

Although Python’s eval() is an incredibly useful tool, the function has some important security implications that you should consider before using it. In this tutorial, you’ll learn how eval() works and how to use it safely and effectively in your Python programs.

In this tutorial, you’ll learn:

How Python’s eval() works
How to use eval() to dynamically evaluate arbitrary string-based or compiled-code-based input
How eval() can make your code insecure and how to minimize the associated security risks

Additionally, you’ll learn how to use Python’s eval() to code an application that interactively evaluates math expressions. With this example, you’ll apply everything you’ve learned about eval() to a real-world problem. If you want to get the code for this application, then you can click on the box below:

Download the sample code: Click here to get the code you'll use to learn about Python's eval() in this tutorial.

Understanding Python’s `eval()`

You can use the built-in Python eval() to dynamically evaluate expressions from a string-based or compiled-code-based input. If you pass in a string to eval(), then the function parses it, compiles it to bytecode, and evaluates it as a Python expression. But if you call eval() with a compiled code object, then the function performs just the evaluation step, which is quite convenient if you call eval() several times with the same input.

The signature of Python’s eval() is defined as follows:

eval(expression[, globals[, locals]])

The function takes a first argument, called expression, which holds the expression that you need to evaluate. eval() also takes two optional arguments:

globals
locals

In the next three sections, you’ll learn what these arguments are and how eval() uses them to evaluate Python expressions on the fly.

Note: You can also use exec() to dynamically execute Python code. The main difference between eval() and exec() is that eval() can only execute or evaluate expressions, whereas exec() can execute any piece of Python code.

The First Argument: `expression`

The first argument to eval() is called expression. It’s a required argument that holds the string-based or compiled-code-based input to the function. When you call eval(), the content of expression is evaluated as a Python expression. Check out the following examples that use string-based input:

>>>

>>> eval("2 ** 8")
256
>>> eval("1024 + 1024")
2048
>>> eval("sum([8, 16, 32])")
56
>>> x = 100
>>> eval("x * 2")
200

When you call eval() with a string as an argument, the function returns the value that results from evaluating the input string. By default, eval() has access to global names like x in the above example.

To evaluate a string-based expression, Python’s eval() runs the following steps:

Parse expression
Compile it to bytecode
Evaluate it as a Python expression
Return the result of the evaluation

The name expression for the first argument to eval() highlights that the function works only with expressions and not with compound statements. The Python documentation defines expression as follows:

expression

A piece of syntax which can be evaluated to some value. In other words, an expression is an accumulation of expression elements like literals, names, attribute access, operators or function calls which all return a value. In contrast to many other languages, not all language constructs are expressions. There are also statements which cannot be used as expressions, such as while. Assignments are also statements, not expressions. (Source)

On the other hand, a Python statement has the following definition:

statement

A statement is part of a suite (a “block” of code). A statement is either an expression or one of several constructs with a keyword, such as if, while or for. (Source)

If you try to pass a compound statement to eval(), then you’ll get a SyntaxError. Take a look at the following example in which you try to execute an if statement using eval():

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

[ 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 #8: Docker + Python for Data Science and Machine Learning

2020-05-08T12:00:00+00:00

Docker is a common tool for Python developers creating and deploying applications, but what do you need to know if you want to use Docker for data science and machine learning? What are the best practices if you want to start using containers for your scientific projects? This week Christopher's guest is Tania Allard, she is a Sr. Developer Advocate at Microsoft focusing on Machine Learning, scientific computing, research and open source. Tania has created a talk for the PyCon US 2020 which is now online. The talk is titled "Docker and Python: Making them Play Nicely and Securely for Data Science and ML." Her talk draws on her expertise in the improvement of processes, reproducibility and transparency in research and data science. They discuss a variety of tools for making your containers more secure and results reproducible. Tania is passionate about mentoring, open-source, and its community. She is an organizer for Mentored Sprints for Diverse Beginners, and she talks about the upcoming online sprints for PyCon US 2020. Christopher and Tania also discuss her plans to start a podcast.

[ 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 Move a Django Model to Another App

2020-05-06T14:00:00+00:00

If you’ve ever thought about refactoring your Django app, then you might have found yourself needing to move a Django model around. There are several ways to move a Django model from one app to another using Django migrations, but unfortunately none of them are straightforward.

Moving models between Django apps is usually a very complicated task that involves copying data, changing constraints, and renaming objects. Because of these complications, the Django object-relational mapper (ORM) does not provide built-in migration operations that can detect and automate the entire process. Instead, the ORM provides a set of low-level migration operations that allow Django developers to implement the process themselves in the migration framework.

In this tutorial, you’ll learn:

How to move a Django model from one app to another
How to use advanced features of the Django migration command line interface (CLI), such as sqlmigrate, showmigrations, and sqlsequencereset
How to produce and inspect a migration plan
How to make a migration reversible and how to reverse migrations
What introspection is and how Django uses it in migrations

After completing this tutorial, you’ll be able to choose the best approach for moving a Django model from one app to another based on your specific use case.

Free Bonus: Click here to get access to a free Django Learning Resources Guide (PDF) that shows you tips and tricks as well as common pitfalls to avoid when building Python + Django web applications.

Example Case: Move a Django Model to Another App

Throughout this tutorial, you’re going work on a store app. Your store is going to start with two Django apps:

catalog: This app is for storing data on products and product categories.
sale: This app is for recording and tracking product sales.

After you finish setting up these two apps, you’re going to move a Django model called Product to a new app called product. In the process, you’ll face the following challenges:

The model being moved has foreign key relationships with other models.
Other models have foreign key relationships with the model being moved.
The model being moved has an index on one of the fields (besides the primary key).

These challenges are inspired by real-life refactoring processes. After you overcome them, you’ll be ready to plan a similar migration process for your specific use case.

Setup: Prepare Your Environment

Before you start moving things around, you need to set up the initial state of your project. This tutorial uses Django 3 running on Python 3.8, but you can use similar techniques in other versions.

Set Up a Python Virtual Environment

First, create your virtual environment in a new directory:

$ mkdir django-move-model-experiment
$ cd django-move-model-experiment
$ python -m venv venv

For step-by-step instructions on creating a virtual environment, check out Python Virtual Environments: A Primer.

Create a Django Project

In your terminal, activate the virtual environment and install Django:

$ source venv/bin/activate
$ pip install django
Collecting django
Collecting pytz (from django)
Collecting asgiref~=3.2 (from django)
Collecting sqlparse>=0.2.2 (from django)
Installing collected packages: pytz, asgiref, sqlparse, django
Successfully installed asgiref-3.2.3 django-3.0.4 pytz-2019.3 sqlparse-0.3.1

You’re now ready to create your Django project. Use django-admin startproject to create a project called django-move-model-experiment:

$ django-admin startproject django-move-model-experiment
$ cd django-move-model-experiment

After running this command, you’ll see that Django created new files and directories. For more about how to start a new Django project, check out Starting a Django Project.

Create Django Apps

Read the full article at https://realpython.com/move-django-model/ »

[ 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 Python print() Function: Go Beyond the Basics

2020-05-05T14:00:00+00:00

If you’re like most Python users, including us, then you probably started your Python journey by learning about print(). It helped you write your very own Hello Horld one-liner. You can use it to display formatted messages onto the screen and perhaps find some bugs. But if you think that’s all there is to know about Python’s print(), then you’re missing out on a lot!

Keep reading to take full advantage of this underappreciated little function. This course will get you up to speed with using Python print() effectively. Prepare for a deep dive as you go through the sections. You may be surprised how much print() has to offer!

By the end of this course, you’ll know how to:

Avoid common mistakes with Python’s print()
Deal with newlines, character encodings, and buffering
Write text to files
Mock print() in unit tests
Build advanced user interfaces in the terminal

Note: print() was a major addition to Python 3, in which it replaced the old print statement available in Python 2.

There were a number of good reasons for that, as you’ll see shortly. Although this tutorial focuses on Python 3, it does show the old way of printing in Python for reference.

[ 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 datetime to Work With Dates and Times

2020-05-04T14:00:00+00:00

Working with dates and times is one of the biggest challenges in programming. Between dealing with time zones, daylight saving time, and different written date formats, it can be tough to keep track of which days and times you’re referencing. Fortunately, the built-in Python datetime module can help you manage the complex nature of dates and times.

In this tutorial, you’ll learn:

Why programming with dates and times is such a challenge
Which functions are available in the Python datetime module
How to print or read a date and time in a specific format
How to do arithmetic with dates and times

Plus, you’re going to develop a neat application to count down the time remaining until the next PyCon US!

Free Bonus: Click here to get our free Python Cheat Sheet that shows you the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Let’s get started!

Programming With Dates and Times

If you’ve ever worked on software that needed to keep track of times across several geographic areas, then you probably have a sense of why programming with time can be such a pain. The fundamental disconnect is that computer programs prefer events that are perfectly ordered and regular, but the way in which most humans use and refer to time is highly irregular.

Note: If you want to learn more about why time can be so complicated to deal with, then there are many great resources available on the web. Here are a few good places to start:

One great example of this irregularity is daylight saving time. In the United States and Canada, clocks are set forward by one hour on the second Sunday in March and set back by one hour on the first Sunday in November. However, this has only been the case since 2007. Prior to 2007, clocks were set forward on the first Sunday in April and set back on the last Sunday in October.

Things get even more complicated when you consider time zones. Ideally, time zone boundaries would follow lines of longitude exactly. However, for historical and political reasons, time zone lines are rarely straight. Often, areas that are separated by large distances find themselves in the same time zone, and adjacent areas are in different time zones. There are some time zones out there with pretty funky shapes.

How Computers Count Time

Nearly all computers count time from an instant called the Unix epoch. This occurred on January 1, 1970, at 00:00:00 UTC. UTC stands for Coordinated Universal Time and refers to the time at a longitude of 0°. UTC is often also called Greenwich Mean Time, or GMT. UTC is not adjusted for daylight saving time, so it consistently keeps twenty-four hours in every day.

By definition, Unix time elapses at the same rate as UTC, so a one-second step in UTC corresponds to a one-second step in Unix time. You can usually figure out the date and time in UTC of any given instant since January 1, 1970, by counting the number of seconds since the Unix epoch, with the exception of leap seconds. Leap seconds are occasionally added to UTC to account for the slowing of the Earth’s rotation but are not added to Unix time.

Note: There’s an interesting bug associated with Unix time. Since many older operating systems are 32-bit, they store the Unix time in a 32-bit signed integer.

This means that at 03:14:07 on January 19, 2038, the integer will overflow, resulting in what’s known as the Year 2038 problem, or Y2038. Similar to the Y2K problem, Y2038 will need to be corrected to avoid catastrophic consequences for critical systems.

Nearly all programming languages, including Python, incorporate the concept of Unix time. Python’s standard library includes a module called time that can print the number of seconds since the Unix epoch:

>>>

>>> import time
>>> time.time()
1579718137.550164

In this example, you import the time module and execute time() to print the Unix time, or number of seconds (excluding leap seconds) since the epoch.

In addition to Unix time, computers need a way to convey time information to users. As you saw in the last example, Unix time is nearly impossible for a human to parse. Instead, Unix time is typically converted to UTC, which can then be converted into a local time using time zone offsets.

The Internet Assigned Numbers Authority (IANA) maintains a database of all of the values of time zone offsets. IANA also releases regular updates that include any changes in time zone offsets. This database is often included with your operating system, although certain applications may include an updated copy.

The database contains a copy of all the designated time zones and how many hours and minutes they’re offset from UTC. So, during the winter, when daylight saving time is not in effect, the US Eastern time zone has an offset of -05:00, or negative five hours from UTC. Other regions have different offsets, which may not be integer hours. The UTC offset for Nepal, for example, is +05:45, or positive five hours and forty-five minutes from UTC.

How Standard Dates Can Be Reported

Unix time is how computers count time, but it would be incredibly inefficient for humans to determine the time by calculating the number of seconds from an arbitrary date. Instead, we work in terms of years, months, days, and so forth. But even with these conventions in place, another layer of complexity stems from the fact that different languages and cultures have different ways of writing the date.

For instance, in the United States, dates are usually written starting with the month, then the day, then the year. This means that January 31, 2020, is written as 01-31-2020. This closely matches the long-form written version of the date.

However, most of Europe and many other areas write the date starting with the day, then the month, then the year. This means that January 31, 2020, is written as 31-01-2020. These differences can cause all sorts of confusion when communicating across cultures.

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

[ 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 #7: AsyncIO + Music, Origins of Black, and Managing Python Releases

2020-05-01T12:00:00+00:00

Want to learn more about AsyncIO in Python, with an example where you can see and hear events being triggered in real-time? This week Christopher interviews Łukasz Langa. Łukasz has created a talk for PyCon 2020 about using AsyncIO with Music. In this talk he shows live examples of coroutines, gathering, the event loop and events being triggered to create a piece of music. They talk about his role as the release manager for Python 3.8 and 3.9. He also provides background on the origins of his very popular, uncompromising code formatter, Black, and the types of problems it can solve inside of an organization. Łukasz previously worked for Facebook, which is where he started Black. He talks about recently moving back to Poland. Łukasz discusses his current work for Edge DB, building a new generation object-relational database.

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

Regular Expressions: Regexes in Python, Part 1

2020-04-29T14:00:00+00:00

In this tutorial, you’ll explore regular expressions, also known as regexes, in Python. A regex is a special sequence of characters that defines a pattern for complex string-matching functionality.

Earlier in this series, in the tutorial Strings and Character Data in Python, you learned how to define and manipulate string objects. Since then, you’ve seen some ways to determine whether two strings match each other:

You can test whether two strings are equal using the equality (==) operator.
You can test whether one string is a substring of another with the in operator or the built-in string methods .find() and .index().

String matching like this is a common task in programming, and you can get a lot done with string operators and built-in methods. At times, though, you may need more sophisticated pattern-matching capabilities.

In this tutorial, you’ll learn:

How to access the re module, which implements regex matching in Python
How to use re.search() to match a pattern against a string
How to create complex matching pattern with regex metacharacters

Fasten your seat belt! Regex syntax takes a little getting used to. But once you get comfortable with it, you’ll find regexes almost indispensable in your Python programming.

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.

Regexes in Python and Their Uses

Imagine you have a string object s. Now suppose you need to write Python code to find out whether s contains the substring '123'. There are at least a couple ways to do this. You could use the in operator:

>>>

>>> s = 'foo123bar'
>>> '123' in s
True

If you want to know not only whether '123' exists in s but also where it exists, then you can use .find() or .index(). Each of these returns the character position within s where the substring resides:

>>>

>>> s = 'foo123bar'
>>> s.find('123')
3
>>> s.index('123')
3

In these examples, the matching is done by a straightforward character-by-character comparison. That will get the job done in many cases. But sometimes, the problem is more complicated than that.

For example, rather than searching for a fixed substring like '123', suppose you wanted to determine whether a string contains any three consecutive decimal digit characters, as in the strings 'foo123bar', 'foo456bar', '234baz', and 'qux678'.

Strict character comparisons won’t cut it here. This is where regexes in Python come to the rescue.

A (Very Brief) History of Regular Expressions

In 1951, mathematician Stephen Cole Kleene described the concept of a regular language, a language that is recognizable by a finite automaton and formally expressible using regular expressions. In the mid-1960s, computer science pioneer Ken Thompson, one of the original designers of Unix, implemented pattern matching in the QED text editor using Kleene’s notation.

Since then, regexes have appeared in many programming languages, editors, and other tools as a means of determining whether a string matches a specified pattern. Python, Java, and Perl all support regex functionality, as do most Unix tools and many text editors.

The `re` Module

Regex functionality in Python resides in a module named re. The re module contains many useful functions and methods, most of which you’ll learn about in the next tutorial in this series.

For now, you’ll focus predominantly on one function, re.search().

re.search(<regex>, <string>)

Scans a string for a regex match.

re.search(<regex>, <string>) scans <string> looking for the first location where the pattern <regex> matches. If a match is found, then re.search() returns a match object. Otherwise, it returns None.

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

Structuring a Python Application

2020-04-28T14:00:00+00:00

Python, though opinionated on syntax and style, is surprisingly flexible when it comes to structuring your applications. On the one hand, this flexibility is great: it allows different use cases to use structures that are necessary for those use cases. On the other hand, though, it can be very confusing to the new developer. The Internet isn’t a lot of help either. There are as many opinions as there are Python blogs!

In this course, you’ll:

Walk through a dependable Python application layout reference guide that you can refer to for most use cases
See examples of common Python application structures, including command-line applications (CLI apps), one-off scripts, installable packages, and web application layouts with popular frameworks like Flask and 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 Python pickle Module: How to Persist Objects in Python

2020-04-27T14:00:00+00:00

As a developer, you may sometimes need to send complex object hierarchies over a network or save the internal state of your objects to a disk or database for later use. To accomplish this, you can use a process called serialization, which is fully supported by the standard library thanks to the Python pickle module.

In this tutorial, you’ll learn:

What it means to serialize and deserialize an object
Which modules you can use to serialize objects in Python
Which kinds of objects can be serialized with the Python pickle module
How to use the Python pickle module to serialize object hierarchies
What the risks are when deserializing an object from an untrusted source

Let’s get pickling!

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you'll need to take your Python skills to the next level.

Serialization in Python

The serialization process is a way to convert a data structure into a linear form that can be stored or transmitted over a network.

In Python, serialization allows you to take a complex object structure and transform it into a stream of bytes that can be saved to a disk or sent over a network. You may also see this process referred to as marshalling. The reverse process, which takes a stream of bytes and converts it back into a data structure, is called deserialization or unmarshalling.

Serialization can be used in a lot of different situations. One of the most common uses is saving the state of a neural network after the training phase so that you can use it later without having to redo the training.

Python offers three different modules in the standard library that allow you to serialize and deserialize objects:

The marshal module
The json module
The pickle module

In addition, Python supports XML, which you can also use to serialize objects.

The marshal module is the oldest of the three listed above. It exists mainly to read and write the compiled bytecode of Python modules, or the .pyc files you get when the interpreter imports a Python module. So, even though you can use marshal to serialize some of your objects, it’s not recommended.

The json module is the newest of the three. It allows you to work with standard JSON files. JSON is a very convenient and widely used format for data exchange.

There are several reasons to choose the JSON format: It’s human readable and language independent, and it’s lighter than XML. With the json module, you can serialize and deserialize several standard Python types:

The Python pickle module is another way to serialize and deserialize objects in Python. It differs from the json module in that it serializes objects in a binary format, which means the result is not human readable. However, it’s also faster and it works with many more Python types right out of the box, including your custom-defined objects.

Note: From now on, you’ll see the terms pickling and unpickling used to refer to serializing and deserializing with the Python pickle module.

So, you have several different ways to serialize and deserialize objects in Python. But which one should you use? The short answer is that there’s no one-size-fits-all solution. It all depends on your use case.

Here are three general guidelines for deciding which approach to use:

Don’t use the marshal module. It’s used mainly by the interpreter, and the official documentation warns that the Python maintainers may modify the format in backward-incompatible ways.
The json module and XML are good choices if you need interoperability with different languages or a human-readable format.
The Python pickle module is a better choice for all the remaining use cases. If you don’t need a human-readable format or a standard interoperable format, or if you need to serialize custom objects, then go with pickle.

Inside the Python `pickle` Module

The Python pickle module basically consists of four methods:

pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None)
pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None)
pickle.load(file, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)
pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None)

The first two methods are used during the pickling process, and the other two are used during unpickling. The only difference between dump() and dumps() is that the first creates a file containing the serialization result, whereas the second returns a string.

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

[ 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 #6: Python REST APIs and The Well-Grounded Python Developer

2020-04-24T12:00:00+00:00

Are you interested in building REST APIs with Flask and SQLAlchemy? This week Christopher interviews Doug Farrell about his four-part Real Python series on Python REST APIs. They discuss the various Python tools and libraries used in the series. Doug also shares his practices for continuous learning. Doug has worked in process control, embedded systems, and has a long background in software development. He's currently a developer at ShutterFly, and discusses developing tools for his internal customers. He also teaches Python to kids at a STEM school near where he lives. Currently Doug is writing a book for Manning Publications, "The Well-Grounded Python Developer". The book is currently available in an early access state. And as always please check out all the additional resources and tools that Doug discusses, they are all gathered for you in the show notes.

[ 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 Pandas DataFrame: Make Working With Data Delightful

2020-04-22T14:00:00+00:00

The Pandas DataFrame is a structure that contains two-dimensional data and its corresponding labels. DataFrames are widely used in data science, machine learning, scientific computing, and many other data-intensive fields.

DataFrames are similar to SQL tables or the spreadsheets that you work with in Excel or Calc. In many cases, DataFrames are faster, easier to use, and more powerful than tables or spreadsheets because they’re an integral part of the Python and NumPy ecosystems.

In this tutorial, you’ll learn:

What a Pandas DataFrame is and how to create one
How to access, modify, add, sort, filter, and delete data
How to handle missing values
How to work with time-series data
How to quickly visualize data

It’s time to get started with Pandas DataFrames!

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you'll need to take your Python skills to the next level.

Introducing the Pandas DataFrame

Pandas DataFrames are data structures that contain:

Data organized in two dimensions, rows and columns
Labels that correspond to the rows and columns

You can start working with DataFrames by importing Pandas:

>>>

>>> import pandas as pd

Now that you have Pandas imported, you can work with DataFrames.

Imagine you’re using Pandas to analyze data about job candidates for a position developing web applications with Python. Say you’re interested in the candidates’ names, cities, ages, and scores on a Python programming test, or py-score:

	`name`	`city`	`age`	`py-score`
`101`	`Xavier`	`Mexico City`	`41`	`88.0`
`102`	`Ann`	`Toronto`	`28`	`79.0`
`103`	`Jana`	`Prague`	`33`	`81.0`
`104`	`Yi`	`Shanghai`	`34`	`80.0`
`105`	`Robin`	`Manchester`	`38`	`68.0`
`106`	`Amal`	`Cairo`	`31`	`61.0`
`107`	`Nori`	`Osaka`	`37`	`84.0`

In this table, the first row contains the column labels (name, city, age, and py-score). The first column holds the row labels (101, 102, and so on). All other cells are filled with the data values.

Now you have everything you need to create a Pandas DataFrame.

There are several ways to create a Pandas DataFrame. In most cases, you’ll use the DataFrame constructor and provide the data, labels, and other information. You can pass the data as a two-dimensional list, tuple, or NumPy array. You can also pass it as a dictionary or Pandas Series instance, or as one of several other data types not covered in this tutorial.

For this example, assume you’re using a dictionary to pass the data:

>>>

>>> data = {
...     'name': ['Xavier', 'Ann', 'Jana', 'Yi', 'Robin', 'Amal', 'Nori'],
...     'city': ['Mexico City', 'Toronto', 'Prague', 'Shanghai',
...              'Manchester', 'Cairo', 'Osaka'],
...     'age': [41, 28, 33, 34, 38, 31, 37],
...     'py-score': [88.0, 79.0, 81.0, 80.0, 68.0, 61.0, 84.0]
... }

>>> row_labels = [101, 102, 103, 104, 105, 106, 107]

data is a Python variable that refers to the dictionary that holds your candidate data. It also contains the labels of the columns:

'name'
'city'
'age'
'py-score'

Finally, row_labels refers to a list that contains the labels of the rows, which are numbers ranging from 101 to 107.

Now you’re ready to create a Pandas DataFrame:

>>>

>>> df = pd.DataFrame(data=data, index=row_labels)
>>> df
       name         city  age  py-score
101  Xavier  Mexico City   41      88.0
102     Ann      Toronto   28      79.0
103    Jana       Prague   33      81.0
104      Yi     Shanghai   34      80.0
105   Robin   Manchester   38      68.0
106    Amal        Cairo   31      61.0
107    Nori        Osaka   37      84.0

That’s it! df is a variable that holds the reference to your Pandas DataFrame. This Pandas DataFrame looks just like the candidate table above and has the following features:

Read the full article at https://realpython.com/pandas-dataframe/ »

[ 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 Coding Interviews: Tips & Best Practices

2020-04-21T14:00:00+00:00

You’ve made it past the phone call with the recruiter, and now it’s time to show that you know how to solve problems with actual code. Whether it’s a HackerRank exercise, a take-home assignment, or an onsite whiteboard interview, this is your moment to prove your coding interview skills.

But interviews aren’t just about solving problems: they’re also about showing that you can write clean production code. This means that you have a deep knowledge of Python’s built-in functionality and libraries. This knowledge shows companies that you can move quickly and won’t duplicate functionality that comes with the language just because you don’t know it exists.

At Real Python, we’ve put our heads together and discussed what tools we’re always impressed to see in coding interviews. This course will walk you through the best of that functionality, starting with Python built-ins, then Python’s native support for data structures, and finally Python’s powerful (and often underappreciated) standard library.

In this course, you’ll learn how to:

Use enumerate() to iterate over both indices and values
Debug problematic code with breakpoint()
Format strings effectively with f-strings
Sort lists with custom arguments
Use generators instead of list comprehensions to conserve memory
Define default values when looking up dictionary keys
Count hashable objects with the collections.Counter class
Use the standard library to get lists of permutations and combinations

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

Effective Python Testing With Pytest

2020-04-20T14:00:00+00:00

Testing your code brings a wide variety of benefits. It increases your confidence that the code behaves as you expect and ensures that changes to your code won’t cause regressions. Writing and maintaining tests is hard work, so you should leverage all the tools at your disposal to make it as painless as possible. pytest is one of the best tools you can use to boost your testing productivity.

In this tutorial, you’ll learn:

What benefits pytest offers
How to ensure your tests are stateless
How to make repetitious tests more comprehensible
How to run subsets of tests by name or custom groups
How to create and maintain reusable testing utilities

Free Bonus: 5 Thoughts On Python Mastery, a free course for Python developers that shows you the roadmap and the mindset you'll need to take your Python skills to the next level.

How to Install `pytest`

To follow along with some of the examples in this tutorial, you’ll need to install pytest. As with most Python packages, you can install pytest in a virtual environment from PyPI using pip:

$ python -m pip install pytest

The pytest command will now be available in your installation environment.

What Makes `pytest` So Useful?

If you’ve written unit tests for your Python code before, then you may have used Python’s built-in unittest module. unittest provides a solid base on which to build your test suite, but it has a few shortcomings.

A number of third-party testing frameworks attempt to address some of the issues with unittest, and pytest has proven to be one of the most popular. pytest is a feature-rich, plugin-based ecosystem for testing your Python code.

If you haven’t had the pleasure of using pytest yet, then you’re in for a treat! Its philosophy and features will make your testing experience more productive and enjoyable. With pytest, common tasks require less code and advanced tasks can be achieved through a variety of time-saving commands and plugins. It will even run your existing tests out of the box, including those written with unittest.

As with most frameworks, some development patterns that make sense when you first start using pytest can start causing pains as your test suite grows. This tutorial will help you understand some of the tools pytest provides to keep your testing efficient and effective even as it scales.

Less Boilerplate

Most functional tests follow the Arrange-Act-Assert model:

Arrange, or set up, the conditions for the test
Act by calling some function or method
Assert that some end condition is true

Testing frameworks typically hook into your test’s assertions so that they can provide information when an assertion fails. unittest, for example, provides a number of helpful assertion utilities out of the box. However, even a small set of tests requires a fair amount of boilerplate code.

Imagine you’d like to write a test suite just to make sure unittest is working properly in your project. You might want to write one test that always passes and one that always fails:

# test_with_unittest.py

from unittest import TestCase

class TryTesting(TestCase):
    def test_always_passes(self):
        self.assertTrue(True)

    def test_always_fails(self):
        self.assertTrue(False)

You can then run those tests from the command line using the discover option of unittest:

$ python -m unittest discover
F.
============================================================
FAIL: test_always_fails (test_with_unittest.TryTesting)
------------------------------------------------------------
Traceback (most recent call last):
  File "/.../test_with_unittest.py", line 9, in test_always_fails
    self.assertTrue(False)
AssertionError: False is not True

------------------------------------------------------------
Ran 2 tests in 0.001s

FAILED (failures=1)

As expected, one test passed and one failed. You’ve proven that unittest is working, but look at what you had to do:

Import the TestCase class from unittest
Create TryTesting, a subclass of TestCase
Write a method in TryTesting for each test
Use one of the self.assert* methods from unittest.TestCase to make assertions

That’s a significant amount of code to write, and because it’s the minimum you need for any test, you’d end up writing the same code over and over. pytest simplifies this workflow by allowing you to use Python’s assert keyword directly:

# test_with_pytest.py

def test_always_passes():
    assert True

def test_always_fails():
    assert False

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

[ 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 #5: Exploring CircuitPython

2020-04-17T12:00:00+00:00

Have you ever wanted to explore using Python with electronics? CircuitPython is a great platform to get started with. This week Christopher talks with Thea Flowers. Thea has been creating several hardware projects based around CircuitPython, and she talks about getting started on the platform. She also answers questions about how she taught herself to design and prototype printed circuit boards. Thea discusses several of her open source projects, including Nox, ConductHotline, and getting involved with CircuitPython. She was the conference co-chair for PyCascades, and Christopher asks her about how someone could get involved in volunteering for conferences. Thea also talks about building diversity in the community. This episode was initially recorded at an earlier date, so Christopher asked Thea to come back for a few minutes to discuss updates on her projects and about a recent honor she received.

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

Sorting Algorithms in Python

2020-04-15T14:00:00+00:00

Sorting is a basic building block that many other algorithms are built upon. It’s related to several exciting ideas that you’ll see throughout your programming career. Understanding how sorting algorithms in Python work behind the scenes is a fundamental step toward implementing correct and efficient algorithms that solve real-world problems.

In this tutorial, you’ll learn:

How different sorting algorithms in Python work and how they compare under different circumstances
How Python’s built-in sort functionality works behind the scenes
How different computer science concepts like recursion and divide and conquer apply to sorting
How to measure the efficiency of an algorithm using Big O notation and Python’s timeit module

By the end of this tutorial, you’ll understand sorting algorithms from both a theoretical and a practical standpoint. More importantly, you’ll have a deeper understanding of different algorithm design techniques that you can apply to other areas of your work. Let’s get started!

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.

The Importance of Sorting Algorithms in Python

Sorting is one of the most thoroughly studied algorithms in computer science. There are dozens of different sorting implementations and applications that you can use to make your code more efficient and effective.

You can use sorting to solve a wide range of problems:

Searching: Searching for an item on a list works much faster if the list is sorted.
Selection: Selecting items from a list based on their relationship to the rest of the items is easier with sorted data. For example, finding the k^th-largest or smallest value, or finding the median value of the list, is much easier when the values are in ascending or descending order.
Duplicates: Finding duplicate values on a list can be done very quickly when the list is sorted.
Distribution: Analyzing the frequency distribution of items on a list is very fast if the list is sorted. For example, finding the element that appears most or least often is relatively straightforward with a sorted list.

From commercial applications to academic research and everywhere in between, there are countless ways you can use sorting to save yourself time and effort.

Python’s Built-In Sorting Algorithm

The Python language, like many other high-level programming languages, offers the ability to sort data out of the box using sorted(). Here’s an example of sorting an integer array:

>>>

>>> array = [8, 2, 6, 4, 5]
>>> sorted(array)
[2, 4, 5, 6, 8]

You can use sorted() to sort any list as long as the values inside are comparable.

Note: For a deeper dive into how Python’s built-in sorting functionality works, check out How to Use sorted() and sort() in Python and Sorting Data With Python.

The Significance of Time Complexity

This tutorial covers two different ways to measure the runtime of sorting algorithms:

For a practical point of view, you’ll measure the runtime of the implementations using the timeit module.
For a more theoretical perspective, you’ll measure the runtime complexity of the algorithms using Big O notation.

Timing Your Code

When comparing two sorting algorithms in Python, it’s always informative to look at how long each one takes to run. The specific time each algorithm takes will be partly determined by your hardware, but you can still use the proportional time between executions to help you decide which implementation is more time efficient.

In this section, you’ll focus on a practical way to measure the actual time it takes to run to your sorting algorithms using the timeit module. For more information on the different ways you can time the execution of code in Python, check out Python Timer Functions: Three Ways to Monitor Your Code.

Here’s a function you can use to time your algorithms:

 1 from random import randint
 2 from timeit import repeat
 3 
 4 def run_sorting_algorithm(algorithm, array):
 5     # Set up the context and prepare the call to the specified
 6     # algorithm using the supplied array. Only import the
 7     # algorithm function if it's not the built-in `sorted()`.
 8     setup_code = f"from __main__ import {algorithm}" \
 9         if algorithm != "sorted" else ""
10 
11     stmt = f"{algorithm}({array})"
12 
13     # Execute the code ten different times and return the time
14     # in seconds that each execution took
15     times = repeat(setup=setup_code, stmt=stmt, repeat=3, number=10)
16 
17     # Finally, display the name of the algorithm and the
18     # minimum time it took to run
19     print(f"Algorithm: {algorithm}. Minimum execution time: {min(times)}")

In this example, run_sorting_algorithm() receives the name of the algorithm and the input array that needs to be sorted. Here’s a line-by-line explanation of how it works:

Line 8 imports the name of the algorithm using the magic of Python’s f-strings. This is so that timeit.repeat() knows where to call the algorithm from. Note that this is only necessary for the custom implementations used in this tutorial. If the algorithm specified is the built-in sorted(), then nothing will be imported.
Line 11 prepares the call to the algorithm with the supplied array. This is the statement that will be executed and timed.
Line 15 calls timeit.repeat() with the setup code and the statement. This will call the specified sorting algorithm ten times, returning the number of seconds each one of these executions took.
Line 19 identifies the shortest time returned and prints it along with the name of the algorithm.

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

Inheritance and Composition: A Python OOP Guide

2020-04-14T14:00:00+00:00

In this course, you’ll explore inheritance and composition in Python. Inheritance and composition are two important concepts in object oriented programming that model the relationship between two classes. They are the building blocks of object oriented design, and they help programmers to write reusable code.

By the end of this course, you’ll know how to:

Use inheritance in Python
Model class hierarchies using inheritance
Use multiple inheritance in Python and understand its drawbacks
Use composition to create complex objects
Reuse existing code by applying composition
Change application behavior at run-time through composition

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

Combining Data in Pandas With merge(), .join(), and concat()

2020-04-13T14:00:00+00:00

Pandas’ Series and DataFrame objects are powerful tools for exploring and analyzing data. Part of their power comes from a multifaceted approach to combining separate datasets. With Pandas, you can merge, join, and concatenate your datasets, allowing you to unify and better understand your data as you analyze it.

In this tutorial, you’ll learn how and when to combine your data in Pandas with:

merge() for combining data on common columns or indices
.join() for combining data on a key column or an index
concat() for combining DataFrames across rows or columns

If you have some experience using DataFrame and Series objects in Pandas and you’re ready to learn how to combine them, then this tutorial will help you do exactly that. If you want a quick refresher on DataFrames before proceeding, then Pandas DataFrames 101 will get you caught up in no time.

You can follow along with the examples in this tutorial using the interactive Jupyter Notebook and data files available at the link below:

Download the notebook and data set: Click here to get the Jupyter Notebook and CSV data set you'll use to learn about Pandas merge(), .join(), and concat() in this tutorial.

Note: The techniques you’ll learn about below will generally work for both DataFrame and Series objects. But for simplicity and conciseness, the examples will use the term dataset to refer to objects that can be either DataFrames or Series.

Pandas `merge()`: Combining Data on Common Columns or Indices

The first technique you’ll learn is merge(). You can use merge() any time you want to do database-like join operations. It’s the most flexible of the three operations you’ll learn.

When you want to combine data objects based on one or more keys in a similar way to a relational database, merge() is the tool you need. More specifically, merge() is most useful when you want to combine rows that share data.

You can achieve both many-to-one and many-to-many joins with merge(). In a many-to-one join, one of your datasets will have many rows in the merge column that repeat the same values (such as 1, 1, 3, 5, 5), while the merge column in the other dataset will not have repeat values (such as 1, 3, 5).

As you might have guessed, in a many-to-many join, both of your merge columns will have repeat values. These merges are more complex and result in the Cartesian product of the joined rows.

This means that, after the merge, you’ll have every combination of rows that share the same value in the key column. You’ll see this in action in the examples below.

What makes merge() so flexible is the sheer number of options for defining the behavior of your merge. While the list can seem daunting, with practice you’ll be able to expertly merge datasets of all kinds.

When you use merge(), you’ll provide two required arguments:

The left DataFrame
The right DataFrame

After that, you can provide a number of optional arguments to define how your datasets are merged:

how: This defines what kind of merge to make. It defaults to 'inner', but other possible options include 'outer', 'left', and 'right'.
on: Use this to tell merge() which columns or indices (also called key columns or key indices) you want to join on. This is optional. If it isn’t specified, and left_index and right_index (covered below) are False, then columns from the two DataFrames that share names will be used as join keys. If you use on, then the column or index you specify must be present in both objects.
left_on and right_on: Use either of these to specify a column or index that is present only in the left or right objects that you are merging. Both default to None.
left_index and right_index: Set these to True to use the index of the left or right objects to be merged. Both default to False.
suffixes: This is a tuple of strings to append to identical column names that are not merge keys. This allows you to keep track of the origins of columns with the same name.

These are some of the most important parameters to pass to merge(). For the full list, see the Pandas documentation.

Note: In this tutorial, you’ll see that examples always specify which column(s) to join on with on. This is the safest way to merge your data because you and anyone reading your code will know exactly what to expect when merge() is called. If you do not specify the merge column(s) with on, then Pandas will use any columns with the same name as the merge keys.

How to `merge()`

Before getting into the details of how to use merge(), you should first understand the various forms of joins:

inner
outer
left
right

Note: Even though you’re learning about merging, you’ll see inner, outer, left, and right also referred to as join operations. For this tutorial, you can consider these terms equivalent.

You’ll learn about these in detail below, but first take a look at this visual representation of the different joins:

Visual Representation of Join Types

Read the full article at https://realpython.com/pandas-merge-join-and-concat/ »

[ 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 #4: Learning Python Through Errors

2020-04-10T12:00:00+00:00

This week Christopher interviews Martin Breuss, about a couple of the video training courses he's created for Real Python. They discuss his course on getting started with Django, and how to learn Python through errors, and how errors really are your friends. Martin talks about his work with Coding Nomads, and teaching Python around the world. He also provides some tips on debugging and writing good questions. This episode was recorded at an earlier date, and because of recent events Martin came back to discuss a new #StayAtHome Mentorship Program he's working on. The program is meant not only for learners but also for those who want to try their hand at being a mentor. We also answer our first listener submitted question.

[ 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 Provide Test Fixtures for Django Models in Pytest

2020-04-08T14:00:00+00:00

If you’re working in Django, pytest fixtures can help you create tests for your models that are uncomplicated to maintain. Writing good tests is a crucial step in sustaining a successful app, and fixtures are a key ingredient in making your test suite efficient and effective. Fixtures are little pieces of data that serve as the baseline for your tests.

As your test scenarios change, it can be a pain to add, modify, and maintain your fixtures. But don’t worry. This tutorial will show you how to use the pytest-django plugin to make writing new test cases and fixtures a breeze.

In this tutorial, you’ll learn:

How to create and load test fixtures in Django
How to create and load pytest fixtures for Django models
How to use factories to create test fixtures for Django models in pytest
How to create dependencies between test fixtures using the factory as fixture pattern

The concepts described in this tutorial are suited for any Python project using pytest. For convenience, the examples use the Django ORM, but the results can be reproduced in other types of ORMs and even in projects that don’t use an ORM or a database.

Fixtures in Django

To get started, you’re going to set up a fresh Django project. Throughout this tutorial, you’ll write some tests using the built-in authentication module.

Setting Up a Python Virtual Environment

When you create a new project, it’s best to also create a virtual environment for it. A virtual environment allows you to isolate the project from other projects on your computer. This way, different projects can use different versions of Python, Django, or any other package without interfering with each other.

Here’s how you can create your virtual environment in a new directory:

$ mkdir django_fixtures
$ cd django_fixtures
django_fixtures $ python -m venv venv

For step-by-step instructions on how to create a virtual environment, check out Python Virtual Environments: A Primer.

Running this command will create a new directory called venv. This directory will store all the packages you install inside the virtual environment.

Setting Up a Django Project

Now that you have a fresh virtual environment, it’s time to set up a Django project. In your terminal, activate the virtual environment and install Django:

$ source venv/bin/activate
$ pip install django

Now that you have Django installed, you can create a new Django project called django_fixtures:

$ django-admin startproject django_fixtures

After running this command, you’ll see that Django created new files and directories. For more about how to start a new Django project, check out Starting a Django Project.

To finish setting up your Django project, apply the migrations for the built-in modules:

$ cd django_fixtures
$ python manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying admin.0003_logentry_add_action_flag_choices... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying auth.0009_alter_user_last_name_max_length... OK
  Applying auth.0010_alter_group_name_max_length... OK
  Applying auth.0011_update_proxy_permissions... OK
  Applying sessions.0001_initial... OK

The output lists all the migrations Django applied. When starting a new project, Django applies migrations for built-in apps such as auth, sessions, and admin.

Now you’re ready to start writing tests and fixtures!

Creating Django Fixtures

Read the full article at https://realpython.com/django-pytest-fixtures/ »

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

Arduino With Python: How to Get Started

2020-04-07T14:00:00+00:00

Microcontrollers have been around for a long time, and they’re used in everything from complex machinery to common household appliances. However, working with them has traditionally been reserved for those with formal technical training, such as technicians and electrical engineers.

The emergence of Arduino has made electronic application design much more accessible to all developers. In this course, you’ll discover how to use Arduino with Python to develop your own electronic projects.

You’ll cover the basics of Arduino with Python and learn how to:

Set up electronic circuits
Set up the Firmata protocol on Arduino
Write basic applications for Arduino in Python
Control analog and digital inputs and outputs
Integrate Arduino sensors and switches with higher-level apps
Trigger notifications on your PC and send emails using Arduino

[ 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 #3: Effective Python and Python at Google Scale

2020-04-03T12:00:00+00:00

In this episode, Christopher interviews Brett Slatkin about the 2nd edition of his book Effective Python. Brett talks about the revisions he made for the book, and updating it for the newest versions of Python 3. Christopher asks who is the intended developer for the book. Brett also discusses working on Google App Engine, and what it's like to develop and maintain Python applications at Google Scale. Brett mentions a brief anecdote about working with Guido van Rossum, while they both worked at Google. He also provides advice about maintaining a large and aging Python code base.

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

Comparing Python Objects the Right Way: "is" vs "=="

2020-03-31T14:00:00+00:00

There’s a subtle difference between the Python identity operator (is) and the equality operator (==). Your code can run fine when you use the Python is operator to compare numbers, until it suddenly doesn’t. You might have heard somewhere that the Python is operator is faster than the == operator, or you may feel that it looks more Pythonic. However, it’s crucial to keep in mind that these operators don’t behave quite the same.

The == operator compares the value or equality of two objects, whereas the Python is operator checks whether two variables point to the same object in memory. In the vast majority of cases, this means you should use the equality operators == and !=, except when you’re comparing to None.

In this course, you’ll learn:

What the difference is between object equality and identity
When to use equality and identity operators to compare objects
What these Python operators do under the hood
Why using is and is not to compare values leads to unexpected behavior
How to write a custom __eq__() class method to define equality operator behavior

[ 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 #2: Learn Python Skills While Creating Games

2020-03-27T12:00:00+00:00

In this episode, Christopher interviews Jon Fincher from the Real Python Team. Jon talks about his recent articles on PyGame and Arcade. They discuss if game programming is a good way to develop your Python programming skills, and if a game would make a good portfolio piece. He compares the two popular Python game libraries of Arcade and PyGame, and discusses about how to find assets for your own creations.

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

Using NumPy's np.arange() Effectively

2020-03-24T14:00:00+00:00

NumPy is the fundamental Python library for numerical computing. Its most important type is an array type called ndarray. NumPy offers a lot of array creation routines for different circumstances. arange() is one such function based on numerical ranges. It’s often referred to as np.arange() because np is a widely used abbreviation for NumPy.

Creating NumPy arrays is important when you’re working with other Python libraries that rely on them, like SciPy, Pandas, Matplotlib, scikit-learn, and more. NumPy is suitable for creating and working with arrays because it offers useful routines, enables performance boosts, and allows you to write concise code.

By the end of this course, you’ll know:

What np.arange() is
How to use np.arange()
How np.arange() compares to the Python built-in class range
Which routines are similar to np.arange()

Let’s see np.arange() 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 ]

The Real Python Podcast – Episode #1: Python Decorators and Writing for Real Python

2020-03-20T14:00:00+00:00

In this first episode, Christopher interviews Geir Arne Hjelle from the Real Python Team. You’ll learn about Geir Arne’s background as a Pythonista and PyCon speaker, the tutorials he’s written for the site, how Python decorators can help you write better code, and what Real Python’s tutorial publishing process looks like behind the scenes.

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

Make a 2D Side-Scroller Game With PyGame

2020-03-17T14:00:00+00:00

In this course, you’ll learn about creating games using Python and the library PyGame.

By the end of this course, you’ll be able to:

Draw items on your screen
Play sound effects and music
Handle user input
Implement event loops
Describe how game programming differs from standard procedural Python programming

This primer assumes you have a basic understanding of writing Python programs, including user-defined functions, imports, loops, and conditionals. You should also be familiar with how to open files on your platform. A basic understanding of object-oriented Python is helpful as well. pygame works with most versions of Python, but Python 3.6 is recommended and used throughout this article.

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

Defining Main Functions in Python

2020-03-10T14:00:00+00:00

Many programming languages have a special function that is automatically executed when an operating system starts to run a program. This function is usually called main() and must have a specific return type and arguments according to the language standard. On the other hand, the Python interpreter executes scripts starting at the top of the file, and there is no specific function that Python automatically executes.

Nevertheless, having a defined starting point for the execution of a program is useful for understanding how a program works. Python programmers have come up with several conventions to define this starting point.

By the end of this course, you’ll understand:

What the special __name__ variable is and how Python defines it
Why you would want to use a main() in Python
What conventions there are for defining main() in Python
What the best practices are for what code to put into your main()

[ 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 #0: About the Show

2020-03-06T00:00:00+00:00

A weekly Python podcast hosted by Christopher Bailey with interviews, coding tips, and conversation with guests from the Python community. The show covers a wide range of topics including Python programming best practices, career tips, and related software development topics. Join us to hear what's new in the world of Python programming and become a better coder.

[ 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

Improve Your Tests With the Python Mock Object Library

Python eval(): Evaluate Expressions Dynamically

Understanding Python’s eval()

The First Argument: expression

The Real Python Podcast – Episode #8: Docker + Python for Data Science and Machine Learning

How to Move a Django Model to Another App

Example Case: Move a Django Model to Another App

Setup: Prepare Your Environment

Set Up a Python Virtual Environment

Create a Django Project

Create Django Apps

The Python print() Function: Go Beyond the Basics

Using Python datetime to Work With Dates and Times

Programming With Dates and Times

How Computers Count Time

How Standard Dates Can Be Reported

The Real Python Podcast – Episode #7: AsyncIO + Music, Origins of Black, and Managing Python Releases

Regular Expressions: Regexes in Python, Part 1

Regexes in Python and Their Uses

A (Very Brief) History of Regular Expressions

The re Module

Structuring a Python Application

The Python pickle Module: How to Persist Objects in Python

Serialization in Python

Inside the Python pickle Module

The Real Python Podcast – Episode #6: Python REST APIs and The Well-Grounded Python Developer

The Pandas DataFrame: Make Working With Data Delightful

Introducing the Pandas DataFrame

Python Coding Interviews: Tips & Best Practices

Effective Python Testing With Pytest

How to Install pytest

What Makes pytest So Useful?

Less Boilerplate

The Real Python Podcast – Episode #5: Exploring CircuitPython

Sorting Algorithms in Python

The Importance of Sorting Algorithms in Python

Python’s Built-In Sorting Algorithm

The Significance of Time Complexity

Timing Your Code

Inheritance and Composition: A Python OOP Guide

Combining Data in Pandas With merge(), .join(), and concat()

Pandas merge(): Combining Data on Common Columns or Indices

How to merge()

The Real Python Podcast – Episode #4: Learning Python Through Errors

How to Provide Test Fixtures for Django Models in Pytest

Fixtures in Django

Setting Up a Python Virtual Environment

Setting Up a Django Project

Creating Django Fixtures

Arduino With Python: How to Get Started

The Real Python Podcast – Episode #3: Effective Python and Python at Google Scale

Comparing Python Objects the Right Way: "is" vs "=="

The Real Python Podcast – Episode #2: Learn Python Skills While Creating Games

Using NumPy's np.arange() Effectively

The Real Python Podcast – Episode #1: Python Decorators and Writing for Real Python

Make a 2D Side-Scroller Game With PyGame

Defining Main Functions in Python

The Real Python Podcast – Episode #0: About the Show

Understanding Python’s `eval()`

The First Argument: `expression`

The `re` Module

Inside the Python `pickle` Module

How to Install `pytest`

What Makes `pytest` So Useful?

Pandas `merge()`: Combining Data on Common Columns or Indices

How to `merge()`