Python's Built-in Functions: A Complete Exploration

Getting the Absolute Value of a Number: abs()

The absolute value or modulus of a real number is its non-negative value. In other words, the absolute value is the number without its sign. For example, the absolute value of -5 is 5, and the absolute value of 5 is also 5.

Python’s built-in abs() function allows you to quickly compute the absolute value or modulus of a number:

>>> from decimal import Decimal
>>> from fractions import Fraction

>>> abs(-42)
42
>>> abs(42)
42

>>> abs(-42.42)
42.42
>>> abs(42.42)
42.42

>>> abs(complex("-2+3j"))
3.605551275463989
>>> abs(complex("2+3j"))
3.605551275463989

>>> abs(Fraction("-1/2"))
Fraction(1, 2)
>>> abs(Fraction("1/2"))
Fraction(1, 2)

>>> abs(Decimal("-0.5"))
Decimal('0.5')
>>> abs(Decimal("0.5"))
Decimal('0.5')

In these examples, you compute the absolute value of different numeric types using the abs() function. First, you use integer numbers, then floating-point and complex numbers, and finally, fractional and decimal numbers. In all cases, when you call the function with a negative value, the final result removes the sign.

For a practical example, say that you need to compute the total profits and losses of your company from a month’s transactions:

>>> transactions = [-200, 300, -100, 500]

>>> incomes = sum(income for income in transactions if income > 0)
>>> expenses = abs(
...     sum(expense for expense in transactions if expense < 0)
... )

>>> print(f"Total incomes: ${incomes}")
Total incomes: $800
>>> print(f"Total expenses: ${expenses}")
Total expenses: $300
>>> print(f"Total profit: ${incomes - expenses}")
Total profit: $500

In this example, to compute the expenses, you use the abs() function to get the absolute value of the expenses, which results in a positive value.

Finding the Quotient and Remainder in Division: divmod()

Python provides a built-in function called divmod() that takes two numbers as arguments and returns a tuple with the quotient and remainder that result from the integer division of the input numbers:

>>> divmod(8, 4)
(2, 0)

>>> divmod(6.5, 3.5)
(1.0, 3.0)

With integers as arguments, the result is the same as (a // b, a % b). With floating-point numbers, the result is (q, a % b), where q is usually math.floor(a / b), but may be 1 less than that.

As a practical example of when to use this function, say that you want to code a function that takes a time value in milliseconds and returns a string with the "00:00:00" format. Here’s a possible implementation using the divmod() function:

>>> def hh_mm_ss(milliseconds):
...     seconds = round(milliseconds / 1000)
...     minutes, seconds = divmod(seconds, 60)
...     hours, minutes = divmod(minutes, 60)
...     return f"{hours:02d}:{minutes:02d}:{seconds:02d}"
...

>>> hh_mm_ss(10000)
'00:00:10'
>>> hh_mm_ss(68000)
'00:01:08'
>>> hh_mm_ss(3680000)
'01:01:20'

In this function, you first convert the input milliseconds to seconds and round the result to the nearest whole number.

Then, you use divmod() to divide the total seconds by 60 because there are 60 seconds in a minute. This computation gives you the minutes and the remaining seconds. Finally, you use divmod() again to divide the minutes by 60 because there are 60 minutes in an hour. This time, you get the hours and the remaining minutes.

Finding Minimum and Maximum Values: min() and max()

Sometimes, you need to find the smallest and largest values in an iterable or in a series of values. These can be common computations in programming, and Python has built-in functions for them.

The min() function allows you to find the minimum value in an iterable, while the max() function helps you find the maximum value. Here’s the signature of both functions:

min(iterable, *[, default, key])
max(iterable, *[, default, key])

Both functions take a required argument called iterable and return the minimum and maximum values, respectively. They also take two optional keyword-only arguments:

Here are some quick examples of how to use the min() and max() functions with different sets of arguments:

>>> min([1, 2, 3, 4])
1
>>> max([1, 2, 3, 4])
4

>>> min(1, 2, 3, 4)
1
>>> max(1, 2, 3, 4)
4

>>> min([], default=0)
0
>>> max([], default=0)
0

>>> min([-2, 3, 4, -5, 1], key=abs)
1
>>> max([-2, 3, 4, -5, 1], key=abs)
-5

In the first two examples, you use min() and max() with a list of numbers. You can also use these functions with a series of positional arguments.

Then, you have two examples of using the default argument to return a suitable value when the input iterable is empty. Finally, you have two examples of using the key argument. In these examples, you use the abs() function to provide the comparison criteria.

Computing Powers: pow()

When you need to compute powers in your code, you can use the built-in pow() function. This function takes a number and raises it to a given power. Here’s the function’s signature:

pow(base, exp[, mod=None])

When you call pow(), you get base to the power of exp. With these two arguments, pow() is equivalent to something like base**exp:

>>> pow(2, 8)
256

>>> 2**8
256

This operation computes 2 to the power of 8, which is 256. This is equivalent to a power operation with the ** operator, which you’ll find more often in real-world code.

The mod argument allows you to do something like pow(base, exp) % mod but computed more efficiently:

>>> import timeit

>>> base = 2
>>> exp = 1000000
>>> mod = 1000000

>>> timeit.timeit(
...     "pow(base, exp, mod)", globals=globals(), number=10
... ) * 1000
0.021042011212557554

>>> timeit.timeit(
...     "pow(base, exp) % mod", globals=globals(), number=10
... ) * 1000
61.956208024639636

In this example, you use the timeit() function from the timeit module to measure the computation speed. Then, you define a few variables to do the computation. In the first call to timeit(), you use the mod argument. In the second call, you use the modulo operator (%).

When you compare the resulting time consumption, you can conclude that using the mod argument is way faster than computing the power and then applying the modulo operator like in pow(base, exp) % mod.

Rounding Numbers: round()

Python’s built-in round() function takes a numeric argument and returns it rounded to a given number of digits.

The signature of round() is shown in the code below:

round(number[, ndigits])

In this signature, number is typically a floating-point number, while ndigits is an optional argument that should be an integer number. This latter argument will define the precision or number of digits after the decimal point.

Here are a few examples:

>>> from math import pi
>>> pi
3.141592653589793

>>> round(pi, 2)
3.14

>>> round(pi, 4)
3.1416

>>> round(pi, 6)
3.141593

In these examples, you use the pi constant from the math module and the round() function to express the number using different precision.

When you use round() with a single argument, you may get surprising results:

>>> round(1.5)
2

>>> round(2.5)
2

In these two examples, the round() function rounds 1.5 up to 2 and 2.5 down to 2. This is because round() rounds to the closest multiple of 10 to the power minus ndigits. If two multiples are equally close, rounding is done toward the even choice. This rounding half to even strategy helps mitigate rounding bias. That’s why 2.5 rounds to 2 rather than 3.

Calculating Totals: sum()

Python’s built-in sum() function provides an efficient and Pythonic way to sum a list of numeric values, which is also a common intermediate step in many computations. So sum() is a pretty handy tool for a Python programmer.

The sum() function allows you to add together a series of values. Its signature is like the following:

sum(iterable[, start=0])

You can call sum() with the following two arguments:

When you call sum(), the function internally adds start plus the values in iterable. The items in the input iterable are usually numeric values. However, you can also use lists or tuples. The start argument can accept a number, list, or tuple, depending on what your iterable contains.

Here are a few examples of how to use sum() with different inputs:

>>> sum([])
0

>>> sum([1, 2, 3, 4, 5])
15

>>> sum([1, 2, 3, 4, 5], 100)  # As a positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # As a keyword argument
115

>>> num_lists = [[1, 2, 3], [4, 5, 6]]
>>> sum(num_lists, start=[])
[1, 2, 3, 4, 5, 6]

>>> num_tuples = ((1, 2, 3), (4, 5, 6))
>>> sum(num_tuples, start=())
(1, 2, 3, 4, 5, 6)

When you call sum() with an empty iterable, you get 0 as a result because that’s the default value of start. Calling the function with a list of values returns the total sum of the provided values.

If you want to use a start value other than 0, then you can provide it as a positional or keyword argument. However, the latter approach is more readable.

The final two examples show that you can also use sum() to concatenate lists and tuples. Note that for this trick to work, you need to set start to the appropriate object. If you want to concatenate lists, then start must hold a list, and so on. Even though this trick works, the practice isn’t efficient or common. Instead, you should use the plus operator (+) for regular concatenations.

A classic example of using sum() is when you need to compute the mean or average of several numeric values. In this situation, you need to sum the input data as an intermediate step. Here’s an example:

def mean(values):
    try:
        return sum(values) / len(values)
    except ZeroDivisionError:
        raise ValueError("mean() arg shouldn't be empty") from None

In this mean() function, you use sum() to sum the input values and then divide the result by the number of values in the input data.

Representing Integer Numbers: int(), bin(), oct(), and hex()

Integer numbers are pretty useful in programming. Python has a built-in data type called int that represents integers. When working with integers, sometimes you need to express them in different bases like 2, 8, or 16. You may also need to convert strings or other numeric types to integers.

For the latter task, you can use the built-in int() function. Here are some examples of using it:

>>> int()
0

>>> int(42.42)
42

>>> int("42")
42

>>> int("42.42")
Traceback (most recent call last):
    ...
ValueError: invalid literal for int() with base 10: '42.42'

>>> int("one")
Traceback (most recent call last):
    ...
ValueError: invalid literal for int() with base 10: 'one'

With no argument, int() returns 0. This behavior is especially useful when you need a factory function for classes like defaultdict from the collections module. With floating-point numbers, int() just removes the decimal part and returns the whole part. Finally, with a string as an argument, int() returns the corresponding integer only if the string represents a valid integer number.

You can also use int() to convert a binary, octal, or hexadecimal string representation into an integer number:

>>> int("0b10", base=2)
2

>>> int("0o10", base=8)
8

>>> int("0x10", base=16)
16

In the first example, you use int() to convert a string representing a number in binary format to its equivalent decimal integer. Note that for this operation to work, you need to set the base argument to the appropriate base, which is 2 for binary numbers. Next, you do similar conversions with octal and hexadecimal strings. Again, you have to set base to the appropriate value.

The bin(), oct(), and hex() functions allow you to do the opposite operation. With them, you can convert a given integer into its binary, octal, or hexadecimal representation:

>>> bin(42)
'0b101010'

>>> oct(42)
'0o52'

>>> hex(42)
'0x2a'

In these examples, you use an integer number as an argument to bin(), oct(), and hex(). As a result, you get the string representation of the input value in binary, octal, and hexadecimal format, respectively.

Manipulating Other Numbers: float() and complex()

Python has basic built-in types to represent floating-point and complex numbers. These types have associated built-in functions for conversion purposes. So, for floating-point numbers, you have the float() function, and for complex numbers you have complex().

Here are the signatures of both functions:

float(number=0.0)

complex(real=0, imag=0)
complex(string)

The float() function takes a single argument representing a numeric value. This argument accepts numbers or strings that represent valid numbers:

>>> float()
0.0

>>> float(42)
42.0

>>> float("42")
42.0

>>> float("3.14")
3.14

>>> float("one")
Traceback (most recent call last):
    ...
ValueError: could not convert string to float: 'one'

With no arguments, float() returns 0.0. With integer numbers, it returns the equivalent floating-point number with 0 as the decimal part. With strings representing numbers, float() returns the equivalent floating-point number. However, it fails if the input string doesn’t represent a valid numeric value.

The complex() function allows you to work with complex numbers. This function has two different signatures. The first signature has two arguments:

These arguments accept numeric values, such as integer or floating-point numbers. Here’s how this variation of complex() works:

>>> complex(3, 6)
(3+6j)

>>> complex(1, 0)
(1+0j)

>>> complex(0, 1)
1j

>>> complex(3.14, -2.75)
(3.14-2.75j)

You can call complex() with numeric values, resulting in a complex number. Note that Python uses a j to define the imaginary part.

The second signature of complex() takes a single argument that should be a string:

>>> complex("3+6j")
(3+6j)

>>> complex("1+0j")
(1+0j)

>>> complex("1j")
1j

>>> complex("3.14-2.75j")
(3.14-2.75j)

When you use strings to create complex numbers with complex(), you have to make sure that the input string has a valid format. It should consist of the real part, the sign, and the imaginary part. You can’t add spaces to separate these components.

Building and Representing Strings: str() and repr()

When it comes to creating and working with Python strings, you have two fundamental built-in functions to consider:

1. str()
2. repr()

With the str() function, you can create new strings or convert existing objects to strings:

>>> str()
''

>>> str(42)
'42'

>>> str(3.14)
'3.14'

>>> str([1, 2, 3])
'[1, 2, 3]'

>>> str({"one": 1, "two": 2, "three": 3})
"{'one': 1, 'two': 2, 'three': 3}"

>>> str({"A", "B", "C"})
"{'B', 'C', 'A'}"

In the first example, you use str() without an argument to create an empty string. In the other examples, you get strings with user-friendly representations of the input objects.

For a practical use case, say that you have a list of numeric values and want to join them using the str.join() method, which only accepts iterables of strings. In this case, you can do something like the following:

>>> "-".join(str(value) for value in [1, 2, 3, 4, 5])
'1-2-3-4-5'

In this example, you use a generator expression to convert each number to its string representation before calling .join(). This way, you avoid getting an error in your code.

For its part, the built-in repr() function gives you a developer-friendly representation of the object at hand:

>>> repr(42)
'42'

>>> repr(3.14)
'3.14'

>>> repr([1, 2, 3])
'[1, 2, 3]'

>>> repr({"one": 1, "two": 2, "three": 3})
"{'one': 1, 'two': 2, 'three': 3}"

>>> repr({"A", "B", "C"})
"{'B', 'C', 'A'}"

For built-in types, the string representation you get with repr() is the same as the one you get with the str() function.

To see the difference between str() and repr(), consider the following example that uses the datetime module:

>>> import datetime
>>> today = datetime.datetime.now()

>>> repr(today)
'datetime.datetime(2024, 7, 1, 12, 38, 53, 180208)'

>>> str(today)
'2024-07-01 12:38:53.180208'

The repr() method gives you a developer-friendly string representation of the datetime object. Ideally, you should be able to re-create the object using this representation. In other words, you should be able to copy and paste the resulting representation to re-create the object. That’s why this string representation is said to be developer-friendly.

In contrast, the string representation that you get from calling str() should aim to be readable and informative for end users.

Processing Boolean Values: bool()

Python’s built-in bool() function allows you to determine the truth value of any Python object. It’s a predicate function because it always returns True or False. To figure out if an object is falsy, in other words, whether bool() returns False when applied to the object, Python uses the following internal rules:

• Constants that are defined to be false: None and False
• The zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• Empty sequences and collections: '', (), [], {}, set(), range(0)

The rest of the objects are considered truthy in Python. Custom objects are considered truthy by default unless they provide a .__bool__() special method that defines a different behavior.

Here are a few examples of how bool() works:

>>> bool()
False

>>> bool(0)
False
>>> bool(42)
True

>>> bool(0.0)
False
>>> bool(3.14)
True

>>> bool("")
False
>>> bool("Hello")
True

>>> bool([])
False
>>> bool([1, 2, 3])
True

In the first example, you call bool() without an argument and get False as a result. In the rest of the examples, you can confirm that Python consistently applies the rules listed above. In practice, you’ll only need to use bool() when your code explicitly requires a Boolean value instead of a different object.

As an example of using bool(), say that you have the following implementation of a stack data structure:

class Stack:
    def __init__(self, items=None):
        self.items = list(items) if items is not None else []

    def push(self, item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()

    def __bool__(self):
        return bool(self.items)

In this example, your Stack class implements the .__bool__() special method to support Boolean operations on its objects. This method guarantees that when a given Stack object is empty, the bool() function returns False and True otherwise. Here’s an example:

>>> from stack import Stack

>>> stack = Stack()

>>> bool(stack)
False

>>> stack.push(4)

>>> bool(stack)
True

In this code snippet, you first create an empty stack. When you pass this object to bool(), you get False. Then, you push a value into the stack and call bool() again. This time, you get True because the stack isn’t empty anymore.

Encoding Strings: ord() and chr()

Character encoding is an important topic in most programming languages. In Python, strings use the Unicode characters set by default. Each Unicode character has an associated code point, which is an integer number. To get the code point of a given character, you can use the built-in ord() function:

>>> ord("A")
65

>>> ord("Z")
90

>>> ord("x")
120

>>> ord("ñ")
241

>>> ord("&")
38

Every Unicode character has an associated code point that uniquely identifies the character in the Unicode table. In these examples, you use the function to get the code point of a few characters.

In practice, you can use the ord() function to implement basic cryptographic techniques, sort strings or characters, validate input characters, and so on. Here’s a quick toy example of a function that only checks whether all the characters in a string are uppercase letters of the English alphabet:

>>> def is_uppercase(text):
...     for char in text:
...         if not (65 <= ord(char) <= 90):
...             return False
...     return True
...

>>> is_uppercase("HELLO")
True

>>> is_uppercase("Hello")
False

In this function, you use ord() to determine whether the characters in a string are between 65 and 90, which is the interval of code points for uppercase letters, A to Z, in the Unicode table.

Sometimes, you may need to determine the code point that identifies a given Unicode character. In this situation, you can use the built-in chr() function:

>>> chr(65)
'A'

>>> chr(90)
'Z'

>>> chr(120)
'x'

>>> chr(241)
'ñ'

>>> chr(38)
'&'

The chr() function does the opposite operation of ord(). It allows you to find the code point associated with a specific character.

The ord() and chr() functions are sort of complementary, and therefore, you’ll probably find them used together in tandem.

Creating Bytes and Bytearrays: bytes() and bytearray()

Python’s bytes and byte arrays are built-in types that Python provides out of the box to manipulate binary data, encode and decode text, process file input and output, and communicate through networks.

The bytes data type is immutable, while the bytearray type is mutable. To create objects derived from these data types, you can use the built-in bytes() and bytearray() functions.

The bytes() and bytearray() functions have the following signatures:

bytes(source=b"")
bytes(source, encoding)
bytes(source, encoding, errors)

bytearray(source=b"")
bytearray(source, encoding)
bytearray(source, encoding, errors)

Both functions have three different signatures. The first signature of both functions accepts a bytes literal as an argument. These literals are similar to string literals, but they start with a b and only accept ASCII characters.

Here’s a summary of the arguments and their meaning:

The encoding argument is only required if the source argument is a string, in which case, you must provide the appropriate encoding so that Python can convert the string into bytes.

Finally, the errors arguments is also optional and should hold one of the following error handlers:

By choosing the appropriate error handlers, you can set up a good strategy for those situations when you call the bytes() and bytearray() functions with erroneous data.

Here are a few examples of using the bytes() and bytearray() functions:

>>> bytes()
b''

>>> bytes(b"Using ASCII characters or bytes \xc3\xb1")
b'Using ASCII characters or bytes \xc3\xb1'

>>> bytes("Using non-ASCII characters: ñ Ł", encoding="utf-8")
b'Using non-ASCII characters: \xc3\xb1 \xc5\x81'

>>> bytearray()
bytearray(b'')

>>> bytearray(b"Using ASCII characters or bytes \xc3\xb1")
bytearray(b'Using ASCII characters or bytes \xc3\xb1')

>>> bytearray("Using non-ASCII characters: ñ Ł", encoding="utf-8")
bytearray(b'Using non-ASCII characters: \xc3\xb1 \xc5\x81')

In these examples, you create bytes and bytearray objects using bytes literals, and strings with the correct encoding as an argument. Note that you can call the bytes() function with no arguments to create an empty bytes object.

Now consider the following examples that show how to use error handlers:

>>> bytes(
...     "Using non-ASCII characters with the ASCII encoding: ñ Ł",
...     encoding="ascii"
... )
Traceback (most recent call last):
    ...
UnicodeEncodeError: 'ascii' codec can't encode character '\xf1'
    in position 52: ordinal not in range(128)

>>> bytes(
...     "Using non-ASCII characters with the ASCII encoding: ñ Ł",
...     encoding="ascii",
...     errors="ignore"
... )
b'Using non-ASCII characters with the ASCII encoding:  '

>>> bytes(
...     "Using non-ASCII characters with the ASCII encoding: ñ Ł",
...     encoding="ascii",
...     errors="replace"
... )
b'Using non-ASCII characters with the ASCII encoding: ? ?'

>>> bytes(
...     "Using non-ASCII characters with the ASCII encoding: ñ Ł",
...     encoding="ascii",
...     errors="xmlcharrefreplace"
... )
b'Using non-ASCII characters with the ASCII encoding: ñ Ł'

>>> bytes(
...     "Using non-ASCII characters with the ASCII encoding: ñ Ł",
...     encoding="ascii",
...     errors="backslashreplace"
... )
b'Using non-ASCII characters with the ASCII encoding: \\xf1 \\u0141'

In these examples, you only use bytes() because bytearray() would work similarly. The only difference is that bytes() returns immutable objects while bytearray() returns mutable ones.

These examples use non-ASCII characters with the ASCII encoding, which will cause encoding errors that you’ll need to handle. The default value of the errors argument is "strict". That’s why you get a UnicodeEncodeError exception in the first example above.

Then you set errors to "ignore" so that Python ignores any encoding error. In this case, the ñ and Ł characters are removed. If you set errors to "replace", then ñ and Ł are each replaced with a question mark.

Using "xmlcharrefreplace" as the error handler makes Python replace the ñ and Ł characters with their respective XML character reference. Finally, using "backslashreplace" escapes the problematic characters by using the appropriate escape sequence.

Creating Lists and Tuples: list() and tuple()

Python’s list is a fundamental built-in data type with an impressive set of features. Lists are mutable and allow you to efficiently organize and manipulate data that can be heterogeneous but is typically homogeneous. For example, you can use a list to store a column from a database table.

Similarly, Python’s tuple is another built-in type. Unlike lists, tuples are immutable. You can use them to organize data that can be homogeneous but is typically heterogeneous. For example, you can use a tuple to store a row from a database table.

Python’s built-in list() and tuple() functions allow you to create list and tuple objects.

The list() function takes an iterable as an argument and returns a list object built out of the input data. So, its signature looks something like the following:

list([iterable])

Note that the square brackets around iterable mean that the argument is optional, so the brackets aren’t part of the syntax.

Here are a few examples of using list() to create list objects:

>>> list()
[]

>>> list("Hello")
['H', 'e', 'l', 'l', 'o']

>>> list((1, 2, 3, 4, 5))
[1, 2, 3, 4, 5]

>>> list({"circle", "square", "triangle", "rectangle", "pentagon"})
['square', 'rectangle', 'triangle', 'pentagon', 'circle']

>>> list({"name": "John", "age": 30, "city": "New York"})
['name', 'age', 'city']
>>> list({"name": "John", "age": 30, "city": "New York"}.keys())
['name', 'age', 'city']

>>> list({"name": "John", "age": 30, "city": "New York"}.values())
['John', 30, 'New York']

>>> list({"name": "John", "age": 30, "city": "New York"}.items())
[('name', 'John'), ('age', 30), ('city', 'New York')]

When you call list() without an argument, you create a new empty list. When you use a string as an argument, you create a list of characters. When you use a tuple, you convert the tuple into a list.

The list() function even accepts sets, but you need to remember that sets are unordered data structures, so you won’t be able to predict the final order of items in the resulting list.

When it comes to using dictionaries with list(), you have four possibilities. You can create a list of keys using the dictionary directly or using its .keys() method. If you want to create a list of values, then you can use the .values() method. Finally, if you want to create a list of key-value pairs, then you can use the .items() method.

Lists have many use cases in Python code. They’re flexible, powerful, and feature-full, so you’ll find them in almost every piece of Python code.

Tuples are commonly used to store heterogeneous and immutable data. The tuple() function allows you to create tuples on the fly. Here’s the signature:

tuple([iterable])

The square brackets around iterable mean that the argument is optional, so the brackets aren’t part of the syntax.

Consider the following examples of using tuple() in your code:

>>> tuple()
()

>>> tuple("Hello")
('H', 'e', 'l', 'l', 'o')

>>> tuple(["Jane Doe", 25, 1.75, "Canada"])
('Jane Doe', 25, 1.75, 'Canada')

>>> tuple({
...     "manufacturer": "Ford",
...     "model": "Mustang",
...     "color": "Blue",
... }.values())
('Ford', 'Mustang', 'Blue')

You can use tuple() with no arguments to create an empty tuple. This will be more readable than using an empty pair of parentheses (). When you pass a string into tuple(), you get a tuple of characters.

In the third example, you use tuple() to convert a list of heterogeneous data into a tuple, which would be a more appropriate data structure for storing this type of data. Finally, you use the values of a dictionary to build a tuple.

Just like lists, tuples are pretty useful in Python. You’ll see them used in many use cases, especially in those situations where you need to store immutable heterogeneous data.

Constructing Dictionaries: dict()

Dictionaries are a fundamental built-in data structure in Python. They’re everywhere and a core part of the language itself. You’ll find many use cases for dictionaries in your code. As for other built-in collections, Python also has a built-in function that allows you to create dictionaries: the dict() function.

The dict() function has the following signatures:

dict(**kwargs)
dict(mapping, **kwargs)
dict(iterable, **kwargs)

All these signatures accept what is known as keyword arguments (**kwargs) or named arguments. The second signature takes a mapping, which can be another dictionary. Finally, the third signature accepts an iterable of key-value pairs, which can be a list of two-item tuples, for example.

Here are some quick examples of using the dict() function in different ways:

>>> dict()
{}

>>> jane = dict(name="Jane", age="30", country="Canada")
>>> jane
{'name': 'Jane', 'age': '30', 'country': 'Canada'}

>>> dict(jane, job="Python Dev")
{'name': 'Jane', 'age': '30', 'country': 'Canada', 'job': 'Python Dev'}

>>> dict([("name", "Jane"), ("age", 30), ("country", "Canada")])
{'name': 'Jane', 'age': 30, 'country': 'Canada'}

Again, when creating an empty dictionary, you can use the dict() function without arguments. This is less common than using a pair of curly brackets {}, but again, it can be more readable and explicit in some contexts.

Then, you create a jane dictionary using keyword arguments. This is a clean and elegant way to build dictionaries in Python.

The third example shows how you can combine a mapping with keyword arguments to create a new dictionary object. Finally, in the fourth example, you create a new dictionary from a list of tuples.

Creating Sets and Frozen Sets: set() and frozenset()

Python’s set is a built-in data type for creating collections of unique and hashable objects, typically called elements or members. In Python, sets support the operations defined for mathematical sets, including union, difference, symmetric difference, and others.

Python has two types of sets:

1. set
2. frozenset

The difference between these two data types is that set objects are mutable, and frozenset objects are immutable.

As with other data types, Python also provides built-in functions for creating sets and frozen sets. You’ll have the set() and frozenset() functions, respectively. The signature for these functions is shown below:

set([iterable])
frozenset([iterable])

Again, the square brackets indicate that the input iterable is optional. Now check out the following examples of creating sets and frozen sets:

>>> set()
set()

>>> frozenset()
frozenset()

>>> set(["square", "rectangle", "triangle", "pentagon", "circle"])
{'square', 'triangle', 'circle', 'rectangle', 'pentagon'}

>>> frozenset(["square", "rectangle", "triangle", "pentagon", "circle"])
frozenset({'square', 'triangle', 'circle', 'rectangle', 'pentagon'})

>>> set(("red", "green", "blue", "red"))
{'green', 'red', 'blue'}

>>> frozenset(("red", "green", "blue", "red"))
frozenset({'green', 'red', 'blue'})

When you call set() and frozenset() without arguments, you create an empty set or frozen set, respectively. In the case of sets, you don’t have a literal that you can use to create an empty set because a pair of curly brackets ({}) defines an empty dictionary. So, to create an empty set, you must use the set() function.

In the rest of the examples, you use iterables, such as lists and tuples, to create sets and frozen sets. It’s important to note that when the input iterable has repeated elements, the final set will have a single instance of the repeated item. Also, sets are unordered data structures, so you won’t be able to predict the final order of items in the resulting set when providing a list.

Determining the Number of Items in a Container: len()

One of the most common operations that you’ll perform on collections is to determine the number of items stored in an existing sequence or collection. To complete this task, Python has the built-in len() function.

The len() function takes a single argument, which can be a sequence, such as a string, tuple, or list. It can also be a collection, such as a dictionary, set, or frozen set. The function returns the length or number of items of the input object.

Here are a few examples of using len() with different objects:

>>> len("Python")
6

>>> len(("Jane Doe", 25, 1.75, "Canada"))
4

>>> len([1, 2, 3, 4, 5])
5

>>> len({"green", "red", "blue"})
3

>>> len({"name": "Jane", "age": 30, "country": "Canada"})
3

In the first example, you use len() to get the number of characters in a string. Then, you use the function to determine the length of a tuple, list, and set. Finally, you use len() with a dictionary as an argument. In this case, you get the number of key-value pairs in the input dictionary.

Note that len() returns 0 when you call it with empty containers:

>>> len("")
0
>>> len(())
0
>>> len([])
0

In these examples, you use len() with an empty string, tuple, and list. In all cases, you get 0 as a result.

The len() function can be useful in several situations. A common example is when you need to compute the average of a series of numeric values:

>>> grades = [90, 97, 100, 87]

>>> sum(grades) / len(grades)
93.5

In this example, len() gives you the number of values in the list of grades. Then, you use this value to compute the average grade.

Reversing and Sorting Iterables: reversed() and sorted()

Reversing and sorting the values in an iterable is another useful operation in programming. Because these operations are so common, Python has built-in functions for them. When you want to reverse an iterable, then you can use the built-in reversed() function.

The reversed() function takes an iterable as an argument and returns an iterator that yields the items in reverse order:

>>> reversed([0, 1, 2, 3, 4, 5])
<list_reverseiterator object at 0x107062b30>

>>> list(reversed([0, 1, 2, 3, 4, 5]))
[5, 4, 3, 2, 1, 0]

In this example, you call reversed() with a list of numbers. The function returns a reverse iterator. To display its content, you can use the list() function to build a list from the iterator.

Similarly, when you need to sort the values in an iterable, you can use the sorted() function. This function has the following signature:

sorted(iterable, key=None, reverse=False)

The first argument is an iterable object, such as a string, list, tuple, or dictionary. Then, you have the key and reverse arguments, which have the following meanings:

It’s important to note that the key argument accepts function objects. In other words, functions without the calling parentheses.

Here are a few examples of using sorted() with different built-in containers as arguments:

>>> sorted("bdeac")
['a', 'b', 'c', 'd', 'e']

>>> sorted([4, 2, 7, 5, 1, 6, 3])
[1, 2, 3, 4, 5, 6, 7]

>>> sorted([4, 2, 7, 5, 1, 6, 3], reverse=True)
[7, 6, 5, 4, 3, 2, 1]

Unlike reversed(), the sorted() function always returns a list object rather than an iterator. In the first example, you use a string as an argument to sorted() and get a list of characters in alphabetical order. Under the hood, Python uses the character’s Unicode code point to compare strings.

In the third example, you set the reverse argument to True and get the list of numbers sorted in reverse order.

Finally, the key argument may be useful in several situations. A common use case for this argument is when you need to sort items that are also containers. Here’s an example of sorting a list of two-value tuples:

>>> points = [(1, 2), (3, 1), (4, 0), (2, 1)]

>>> sorted(points, key=lambda point: point[0])
[(1, 2), (2, 1), (3, 1), (4, 0)]

>>> sorted(points, key=lambda point: point[1])
[(4, 0), (3, 1), (2, 1), (1, 2)]

In the first highlighted line, you use a lambda function that takes a point as an argument and returns its first coordinate. This example would produce the same result if you call sorted() without key because of the way Python compares tuples. In the second highlighted line, the lambda function returns the second coordinate. These functions provide comparison keys for the sorting processes.

So, in the first example, you sort the points by their first coordinate, while in the second example, you sort points by their second coordinate.

Determining the Truth Value of Items in Iterables: all() and any()

Sometimes, you may need to determine whether all the items in an iterable are true. To do this, Python has the built-in all() function. At other times, you may need to find out if at least one item in an iterable is true. For this purpose, Python has the built-in any() function.

The signature of all() and any() are shown below:

all(iterable)

any(iterable)

Both functions take an iterable of objects as an argument. The all() function returns True when all the items in the input iterable are true and False when at least one item is false.

Here are a few examples of how all() works:

>>> all([1, 2, 3, 4])
True
>>> all([1, 2, 3, 4, 0])
False

>>> all(["Hello", ""])
False
>>> all(["Hello", "World"])
True

In the first two examples, you use all() with a list of numbers. The first list contains integer values different from 0, which Python considers true. So, all() returns True. Then, in the second example, you add a 0 to the list, and all() returns False because this value is considered false in Python.

In the final two examples, you use a list of strings. Python considers an empty string false, so all() returns False. Finally, you pass a list with two non-empty strings, and all() reruns True.

You may find several use cases for all() in real-world code. Perhaps passing a generator expression as an argument to all() is one of the most powerful ways to use the function. For example, say that you want to determine whether all the numbers in a list are in a given interval. In this situation, you can use all() like in the following code:

>>> numbers = [10, 5, 6, 4, 7, 8, 18]

>>> # Between 0 and 10
>>> all(0 <= x <= 10 for x in numbers)
False

>>> # Between 0 and 20
>>> all(0 <= x <= 20 for x in numbers)
True

In the first highlighted line, you use a generator expression as an argument to all(). The generator checks whether the numbers are between 0 and 10 and generates Boolean values according to the condition’s result.

The all() function checks if all the generated values are True. If that’s the case, then you get True. On the other hand, if at least one of the generated values is False, then you get False.

In contrast to all(), the any() function returns True if at least one item is true and False if all the items are false. So, you can use any() when you need to determine if at least one item in an iterable is true.

Here are a couple of examples of using any() in Python:

>>> any([0, 0.0, False, "", []])
False

>>> any([0, 0.0, False, "", [], 42])
True

In the first example, all the objects in the input list are false according to Python’s internal rules for determining the truth value of an object. Because all the objects are false, any() returns False. In the second example, you add the number 42 to the end of the input list. Because 42 is truthy, any() returns True.

Again, just like all(), the any() function can shine when you use it with a generator expression that checks for some condition. For example, say that you want to know if at least one letter in a given text is in uppercase. In this situation, you can do something like the following:

>>> any(letter.isupper() for letter in  "hello, world!")
False

>>> any(letter.isupper() for letter in  "Hello, World!")
True

In these examples, you use the str.isupper() method to determine whether a letter is in uppercase. This method returns True or False, so you get an iterable of Boolean values. The job of any() is to determine if any of these values is true.

In the first example, you have no uppercase letters, so any() returns False. In the second example, you have an uppercase H, so any() returns True.

Creating Ranges of Integer Values: range()

Sometimes, you need to build numerical ranges to represent a series of integer values in a given interval. Usually, you need the numbers to be consecutive, but you may also want them to be nonsequential.

For example, you can create a range of values that contains all the digits using a Python list:

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

This approach will work if your range is relatively small like the one in this example. However, what if your range needs to have a million values? Building that kind of range with a list would be a difficult task. There’s a better way.

Python has the built-in range() function to facilitate the creation of numerical ranges:

>>> range(10)
range(0, 10)

>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> range(1_000_000)
range(0, 1000000)

>>> list(range(1_000_000))
[1, 2, 3,
 ...,
 999998, 999999]

The range() function returns a range object rather than a list. If you want to check the values in a concrete range, then you can wrap it in a call to list(), as you did in the second example. Now you have a list of digits.

In the third example, you create a range with a million integers from 0 to 999999. If you want to see it in action, pass it to list(). You’ll get a terminal window full of numbers!

The built-in range() function has the following signatures:

range(stop)
range(start, stop, step=1)

You have a one-argument and three-argument variant of the function. Here’s what each argument means:

So far, you’ve used the one-argument variation, which starts the range at 0 and builds a range of consecutive integers. Here are a couple of examples showing the three-argument variation:

>>> list(range(1, 11))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> list(range(10, 101, 10))
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

Note that in the three-argument variation, the third argument is optional. This means that you can call the function with two arguments and rely on the default value of step, which is 1. That’s what you do in the first example, which builds a range of consecutive integers from 1 to 11. Again, 11 isn’t included in the final range because it’s the value at which range() stops issuing values.

In the second example, you create a range that starts at 10 and goes up to 101 with a step of 10.

You can also use negative values for the arguments of range(). A common use case for this is when you need to create ranges of negative numbers and ranges that count backward:

>>> list(range(-10, 0))
[-10, -9, -8, -7, -6, -5, -4, -3, -2, -1]

>>> list(range(100, 0, -10))
[100, 90, 80, 70, 60, 50, 40, 30, 20, 10]

In this example, the first range contains consecutive negative numbers from -10 up to 0. The second range counts backward from 100 to 0 with a step of -10.

Ranges can be useful in several situations. A good use case for a range is when you need to perform an operation a given number times:

>>> for _ in range(3):
...     print("Beep")
...
Beep
Beep
Beep

This loop runs three times and prints a message to the screen. However, the loop doesn’t need to use the loop variable in its body. So, you use an underscore to denote that this is a throwaway variable.

A common misuse of range objects in Python is to use them as a way to loop over an existing iterable:

>>> letters = ["a", "b", "c", "d"]

>>> for index in range(len(letters)):
...     print(index, letters[index])
...
0 a
1 b
2 c
3 d

This kind of for loop isn’t the best example of a Pythonic construct. It uses range() to loop over the letters with numeric indices. In the following section, you’ll learn about the Pythonic way to write this kind of loop.

Enumerating Items in Loops: enumerate()

A Pythonic for loop iterates over the items in an iterable without considering the index at which a given item lives or the order in which the items were processed. You’ll find that most Python for loops will look something like the following:

>>> colors = ["red", "orange", "yellow", "green"]

>>> for color in colors:
...     print(color)
...
red
orange
yellow
green

This way of writing loops in Python is explicit and intuitive, which deeply impacts the loop’s readability. However, sometimes you’ll need a way to access the index where a given item lives in the input iterable.

Often, when you’re starting with Python and need to access indices in a loop, you might end up writing a loop like the following:

>>> for index in range(len(colors)):
...     print(index, colors[index])
...
...
0 red
1 orange
2 yellow
3 green
4 blue
5 indigo
6 violet

This kind of loop works. However, it’s not what you can call a Pythonic loop. It uses a couple of tricks to somehow mimic iteration over indices. Python offers a better tool to do this, and that tool is the built-in enumerate() function.

Here’s how you’ll write the above loop using the enumerate() function:

>>> for index, color in enumerate(colors):
...     print(index, color)
...
0 red
1 orange
2 yellow
3 green
4 blue
5 indigo
6 violet

This loop is readable and explicit. The enumerate() function takes an iterable as an argument and generates two-item tuples containing an integer index and the associated item.

Here’s the function’s signature:

enumerate(iterable, start=0)

The first argument is an iterable object. The second argument, start, gives you the option to define a starting value for the enumeration. The default value is 0 because that’s the usual start value of indices in programming. However, in some situations, using a different starting point, like 1, can be convenient.

To illustrate how to use the start argument, say that you’re building a text-based user interface (TUI) application and want to display a menu with some options. The options should have an associated number so that the user can choose the desired action. In this situation, you can use enumerate() as in the code below:

>>> def list_menu(options):
...     print("Main Menu:")
...     for index, option in enumerate(options, start=1):
...         print(f"{index}. {option}")
...

>>> list_menu(["Open", "Save", "Settings", "Quit"])
Main Menu:
1. Open
2. Save
3. Settings
4. Quit

From the end user’s perspective, starting the menu list at 1 is the natural way to go. You can achieve this effect by setting start to 1 in the call to enumerate(). Now, the menu starts at 1 instead of 0.

Extracting Slices or Portions of Sequences: slice()

When you’re working with Python, you may need to extract a portion or a slice of an existing sequence, such as a string, list, or tuple. To do this, you typically use the slicing operator ([]). However, you can also use the built-in slice() function. The slice() function has the following signatures:

slice(stop)
slice(start, stop, step=None)

The slice() function returns a slice object representing the set of indices specified by range(start, stop, step). The arguments here have a similar meaning as in the range() function:

Slices don’t represent numeric ranges but sets of indices. You can use these indices to extract a portion of a list. Here are a few examples:

>>> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> even = numbers[slice(1, None, 2)]
>>> even
[2, 4, 6, 8]

>>> odd = numbers[slice(None, None, 2)]
>>> odd
[1, 3, 5, 7, 9]

In the first slice, you start at 1 and go up to the end of the list with a step of 2. This slice gives you a list of even numbers. In the second example, you start at the beginning of the list and go up to the end of the list with a step of 2. With this slice, you get a list of odd numbers.

Note that in most Python code, you won’t see or use slice() the way you did in the example above. In most cases, you’ll use the slicing operator, [start:stop:step]. Here’s what this looks like with this operator:

>>> even = numbers[1::2]
>>> even
[2, 4, 6, 8]

>>> odd = numbers[::2]
>>> odd
[1, 3, 5, 7, 9]

In these examples, you use the slicing operator to get the even and odd numbers from your original list. Note that skipping a given index makes that index rely on its default value. For example, when you don’t provide a start index, then it defaults to the beginning of the list.

Zipping Iterables for Parallel Iteration: zip()

Python’s built-in zip() function allows you to iterate over multiple iterables in parallel. This function creates an iterator that will aggregate elements from two or more iterables, yielding tuples of values.

Here’s the signature of the built-in zip() function:

zip(*iterables, strict=False)

This function takes an undefined number of iterables as arguments and yields tuples of items on demand. The tuples will contain an item from each input iterable, making it ideal for parallel iteration.

Here are some quick examples:

>>> letters = ["a", "b", "c"]
>>> numbers = [1, 2, 3]
>>> operators = ["*", "/", "+"]

>>> for characters in zip(letters, numbers, operators):
...     print(characters)
...
('a', 1, '*')
('b', 2, '/')
('c', 3, '+')

>>> for l, n, o in zip(letters, numbers, operators):
...     print(f"{l} {n} {o}")
...
a 1 *
b 2 /
c 3 +

In the first loop, you use a single loop variable to store each tuple that you get from zip(). The first tuple contains the first items of each input iterable. The second tuple contains the second items, and so on. In the second loop, you use three loop variables to unpack the items of each generated tuple.

A nice use case of zip() is when you have two lists and want to create a dictionary from them. Consider the following example:

>>> keys = ["name", "age", "country"]
>>> values = ["Jane", "30", "Canada"]

>>> dict(zip(keys, values))
{'name': 'Jane', 'age': '30', 'country': 'Canada'}

In this example, you combine two existing lists using zip() and pass the resulting tuples to the dict() function to create a dictionary.

The strict argument to zip() was added in Python 3.10 and is a keyword-only argument that provides a safe way to handle iterables of unequal length. The argument’s default value is False, which means that zip() will only generate as many tuples as items in the shortest iterable.

If you set strict to True, then you’ll get a ValueError exception when the input iterables don’t have the same length:

>>> list(zip(range(5), range(100)))
[(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]

>>> list(zip(range(5), range(100), strict=True))
Traceback (most recent call last):
    ...
ValueError: zip() argument 2 is longer than argument 1

In the first argument, you rely on the default value of strict and get five tuples because the shortest range only has five values. In the second example, you set strict to True. This time, you get an error because the input ranges don’t have the same number of values.

Building and Consuming Iterators: iter() and next()

In Python, iterators implement the iterator design pattern, which allows you to traverse a container and access its elements. The iterator pattern decouples the iteration algorithms from containers, such as lists, tuples, dictionaries, and sets.

Python has two built-in functions that can help you out when working with iterators. The iter() function allows you to build an iterator from an iterable, and the next() function lets you consume an iterator one item at a time.

Consider the following toy example:

>>> colors = ["red", "orange", "yellow", "green"]

>>> colors_it = iter(colors)
>>> colors_it
<list_iterator object at 0x10566a170>

>>> next(colors_it)
'red'
>>> next(colors_it)
'orange'
>>> next(colors_it)
'yellow'
>>> next(colors_it)
'green'
>>> next(colors_it)
Traceback (most recent call last):
    ...
StopIteration

In this example, you use the iter() function to create an iterator object from an existing list of colors. Unlike iterables, iterators support the next() function. When you call this function with an iterator as an argument, you get the first item in the first call. When you call the function again, you get the second item, and so on.

When you traverse all the items in the iterator, next() raises a StopIteration exception. Python internally uses this exception to stop the iteration process in a for loop or a comprehension. Note that you can traverse an iterator only once. After that, the iterator will be exhausted or consumed.

Here are the signatures of iter() :

iter(iterable)
iter(object, sentinel)

In the first signature, iterable represents any iterable type. In the second signature, the object argument must be a callable. You’ve already seen the first signature in action. Now, it’s time to take a quick look at the second signature.

To illustrate with an example, say that you’re working on a command-line interface (CLI) app and want to take the user’s input until they enter the word "done". Here’s how you can do this using the iter() function:

>>> def read_user_input():
...     print("Enter word (type 'done' to finish):")
...     for word in iter(input, "done"):
...         print(f"Processing word: '{word}'")
...

>>> read_user_input()
Enter word (type 'done' to finish):
Python
Processing word: 'Python'
Programming
Processing word: 'Programming'
Iterators
Processing word: 'Iterators'
done

In the highlighted line, you use iter() with two arguments. For the first argument, you use the built-in input() function, which allows you to take input from the user. Note that you don’t call the function but pass it as a function object.

Then, you have the word "done", which works as a sentinel. In other words, iter() will call input() for you and raise a StopIteration exception if its return value matches the sentinel word.

When you call the function, you’re asked to enter a word, then the code processes the word and lets you enter another word. These actions repeat until you enter your sentinel, the word "done".

When it comes to the next() function, you’ll also have two different signatures that looks something like this:

next(iterator)
next(iterator, default)

Again, you’ve seen how to use next() with an iterable as its unique argument. Now, you can focus on using the second signature. In this case, you have a second argument called default. This argument allows you to provide the value that you want to return when the input iterable is exhausted or its data is over:

>>> count_down = iter([3, 2, 1])

>>> next(count_down, 0)
3
>>> next(count_down, 0)
2
>>> next(count_down, 0)
1
>>> next(count_down, 0)
0
>>> next(count_down, 0)
0

In this example, you create an iterator from a list of numbers. Then, you use next() to consume the iterator one number at a time. After next() has consumed the entire iterator, you get 0 as a result because that’s the value you passed to default, the second positional argument. Successive calls to the function will return 0 as well.

Filtering and Mapping Iterables: filter() and map()

Have you heard about functional programming? It’s a programming paradigm where a program is dominated by calls to pure functions, which are functions whose output values depend solely on their input values without any observable side effects.

Python isn’t what you could call a functional programming language. However, it has a couple of built-in functions that are classical functional tools. These tools are the built-in filter() and map() functions.

You can use the filter() function to extract values from iterables, which is known as a filtering operation.

The signature of filter() looks something like this:

filter(function, iterable)

The first argument, function, must be a single-argument function, while the second argument can be any Python iterable. Here’s a short description of these arguments:

The function argument is a decision function, also known as a filtering function. It provides the criteria for deciding whether to keep a given value.

In practice, filter() applies function to all the items in iterable. Then, it creates an iterator that yields only the items that meet the criteria that function checks. In other words, it yields the items that make function return True.

The filter() function allows you to process iterables without a formal loop. Here’s an example of using filter() to extract even numbers from a list of values:

>>> numbers = [1, 3, 10, 45, 6, 50]

>>> list(filter(lambda n: n % 2 == 0, numbers))
[10, 6, 50]

In this example, the lambda function takes an integer and returns True if the input value is an even number and False otherwise. The call to filter() applies this lambda function to the values in numbers and filters out the odd numbers, returning the even numbers. Note that you use the list() function to create a list from the iterator that filter() returns.

The map() function is another common tool in functional programming. This function allows you to apply a transformation function to all the values in an iterable.

Python’s map() has the following signature:

map(function, iterable, *iterables)

The map() function applies function to each item in iterable in a loop and returns a new iterator that yields transformed items on demand.

Here’s a summary of the arguments and their meanings:

The function argument is what is called a transformation function. It applies a specific transformation to its arguments and returns a transformed value.

To illustrate how map() works, say that you have two lists. The first list contains a series of values that you want to use as the bases in power computations. The second list contains the exponents that you want to apply to each base. You can use the map() function to process these lists and get an iterator of powers:

>>> bases = [8, 5, 2]
>>> exponents = [2, 3, 4]

>>> list(map(pow, bases, exponents))
[64, 125, 16]

In this example, you use the built-in pow() function as the first argument to map(). As you already learned, pow() takes a base and an exponent as arguments and returns the power. Then, you pass the bases and exponents to map() so that it computes the desired powers.

Accepting Input From the User: input()

Taking input from your users is a common operation in CLI and text-based interface (TUI) applications. Python has a built-in function that’s specifically targeted to this type of operation. The function is conveniently called input().

The built-in input() function reads the user’s input and grabs it as a string. Here’s the function’s signature:

input([prompt])

The square brackets around prompt are an indication that this argument is optional. This argument allows you to provide a prompt to ask the user for the required or desired input.

As an example of using input(), say that you want to create a number-guessing game. The game will prompt the user to enter a number from 1 to 10 and check if the input value matches a secret number.

Here’s the code for the game:

from random import randint

LOW, HIGH = 1, 10

secret_number = randint(LOW, HIGH)
clue = ""

while True:
    guess = input(f"Guess a number between {LOW} and {HIGH} {clue} ")
    number = int(guess)
    if number > secret_number:
        clue = f"(less than {number})"
    elif number < secret_number:
        clue = f"(greater than {number})"
    else:
        break

print(f"You guessed it! The secret number is {number}")

In this code, you define an infinite loop where you prompt the user to make their guess by entering a number between 1 and 10. The first line in the loop is a call to the built-in input() function. You’ve used a descriptive prompt to inform the users what to do.

Go ahead and run the script from your command line to try it out:

$ python guess.py
Guess a number between 1 and 10  2
Guess a number between 1 and 10 (greater than 2) 3
Guess a number between 1 and 10 (greater than 3) 8
Guess a number between 1 and 10 (less than 8) 6
You guessed it! The secret number is 6

Cool! Your game asks the user to enter a number, compares it with the secret number, and lets the users know when they guess correctly. The input() function plays a core role in the game’s flow, allowing you to get and process the user’s input.

Opening Files: open()

Reading from and writing to files are common programming tasks. In Python, you can use the built-in open() function for these purposes. You typically use the open() function in a with statement.

As a quick example, say that you have a text file with the following content:

apple
banana
cherry
orange
mango

You want to open the file and read its content while you print it to the screen. To do this, you can use the following code:

>>> with open("fruits.txt") as file:
...     print(file.read())
...
apple
banana
cherry
orange
mango

In this with statement, you call open() with the filename as an argument. This call opens the file for reading. The open() function returns a file object, which the with statement assigns to the file variables with the as specifier.

The open() function has the following signature:

open(
    file,
    mode="r",
    buffering=-1,
    encoding=None,
    errors=None,
    newline=None,
    closefd=True,
    opener=None,
)

The function can take up to eight arguments. The first argument, file, is the only required argument. The rest of the arguments are optional. Here’s a summary of the arguments’ meaning:

In this tutorial, you won’t cover all these arguments. Instead, you’ll learn about two of the most commonly used arguments, which are mode and encoding.

Here’s a list of allowed mode values:

In this table, the "b" and "t" values define two generic modes for binary and text files, respectively. You can combine these two modes with other modes. For example, the "wb" mode allows you to write binary data to a file, the "rt" mode enables you to read text-based data from a file, and so on.

Note that "t" is the default mode. So, if you set the mode to "w", Python assumes that you want to write text to the target file.

Here’s a code snippet that writes some text to a file in your working directory:

>>> with open("hello.txt", "w") as file:
...     file.write("Hello, World!")
...
13

In this example, you open a file called hello.txt so you can write text to it. In the code block of the with statement, you call the .write() method on the file object to write some text. Note that the method returns the number of written bytes. That’s why you get 13 on the screen.

After running the code, you’ll have the hello.txt file in your working directory. Go ahead and open it to check its content.

You can experiment with other modes and get an idea of how they work so that you can use them safely in your code. Take this as a practical exercise!

Using the encoding argument is another typical requirement when you’re working with text files. In this situation, it’s a best practice to explicitly state the text encoding that you’re using in your code. The UTF-8 encoding is a common example of a value that you’d pass to encoding:

>>> with open("hello.txt", "w", encoding="utf-8") as file:
...     file.write("Hello, Pythonista!")
...
13

>>> with open("hello.txt", "r", encoding="utf-8") as file:
...     print(file.read())
...
Hello, Pythonista!

In this example, you use the UTF-8 encoding to write and read from a text file. Note that you need to explicitly use the argument’s name to provide the encoding value. This is because the following argument in the list is buffering rather than encoding, and if you don’t use the explicit name, then you get a TypeError exception.

Printing Text to the Screen or Another Output: print()

Another common requirement that arises when you’re creating CLI or TUI applications is to display information on the screen to inform the user about the app’s state. In this case, you can use the built-in print() function, which is a fundamental tool in Python programming.

The print() function has the following signature:

print(*objects, sep=" ", end="\n", file=None, flush=False)

Calling print() will print the input objects to the screen by default. You can use the rest of the arguments to tweak how the function works. Here’s a summary of the arguments and their meaning:

When you call print(), it takes the input objects, converts them into strings, joins them using sep, and appends end. If you call print() with no argument, then it prints end. Note that the arguments sep, end, file, and flush are keyword arguments.

Here are a few examples of how to use the print() function:

>>> print()

>>> print("Hello")
Hello
>>> print("Hello", "Pythonista!")
Hello Pythonista!
>>> print("Hello", "Pythonista!", sep="\t")
Hello    Pythonista!
>>> print("Hello", "Pythonista!", sep="\t", end=" 👋\n")
Hello    Pythonista! 👋

When you call print() with no arguments, then end is printed on the screen. This argument defaults to a newline character, so that’s what you get. With an object as an argument, the object is printed, followed by a newline character. With several objects as arguments, the arguments are joined by sep, and a newline is added at the end.

You can also tweak the value of end and make Python print something different at the end of your output.

The file argument defaults to the standard output, which is your screen. The sys.stdout stream provides this default value. However, you can redirect the output to a file object of your preference:

>>> with open("hello.txt", mode="w") as text_file:
...     print("Hello, World!", file=text_file)
...

This code snippet will override your existing hello.txt file from the previous section, writing the phrase "Hello, World!" into it.

Finally, you have the flush argument that has to do with data buffering. By default, Python buffers the calls to print() in a RAM data buffer. This allows Python to make fewer system calls for write operations by batching characters in the buffer and writing them all at once with a single system call.

You can set the flush argument to True if you want your code’s output to display in real time. If you keep flush at its default value of False, then Python will buffer the output, and that output will only show up once the data buffer is full or when your program finishes execution.

A cool example of using flush is when you need to create a progress bar for a CLI application. Consider the following function:

def progress(percent=0, width=30):
    end = "" if percent < 100 else "\n"
    left = width * percent // 100
    right = width - left
    print(
        "\r[",
        "#" * left,
        " " * right,
        "]",
        f" {percent:.0f}%",
        sep="",
        end=end,
        flush=True,
    )

This function generates a horizontal progress bar by taking advantage of the flush argument. Here’s how you can use it in your code:

>>> from time import sleep
>>> from progress import progress

>>> for percent in range(101):
...     sleep(0.2)
...     progress(percent)
...
[###########                   ] 38%

This loop calls progress() with successive hypothetical progress values. The output of each call is flushed and the progress bar is displayed in the same line.

Formatting Strings: format()

Python has a couple of handy tools for string interpolation and formatting, including f-strings and the str.format() method. These tools take advantage of Python’s string formatting mini-language, which allows you to nicely format your strings using a dedicated syntax.

The built-in format() function is another tool that you can use to format values. The function has the following signature:

format(value, format_spec="")

The function converts value to a formatted representation. To define the desired format, you can use the format_spec argument, which accepts a string that follows the syntax defined in the string formatting mini-language. The format_spec argument defaults to an empty string, which causes the function to return the value as passed.

Consider the following examples of using the format() function:

>>> import math
>>> from datetime import datetime

>>> format(math.pi, ".4f")  # Four decimal places
'3.1416'

>>> format(math.pi, "e")  # In scientific notation
'3.141593e+00'

>>> format(1000000, ",.2f")  # Thousand separators
'1,000,000.00'

>>> format("Header", "=^30")  # Centered and filled
'============Header============'

>>> format(datetime.now(), "%a %b %d, %Y")  # Date
'Mon Jul 1, 2024'

In these examples, you’ve used several different format specifiers. The ".4f" specifier formats the input value as a floating-point number with four decimal places. The "e" specifier allows you to format the input value using scientific notation.

With the ",.2f" format specifier, you can format a number using commas as thousand separators and with two decimal places, which is an appropriate format for currency values. Then, you use the "=^30" specifier to format the string "Header" centered in a width of 30 characters using the equal sign as a filler character. Finally, you use the "%a %b %d, %Y" to format a date.

Building Properties: property()

Python’s built-in property() function allows you to create managed attributes in your classes. Managed attributes, also known as properties, have an associated value and an internal implementation or function-like behavior.

To illustrate this with an example, say that you want to create a Point class. In Python, you’ll start with something like the following:

>>> class Point:
...     def __init__(self, x, y):
...         self.x = x
...         self.y = y
...

>>> point = Point(42, 21)

>>> point.x
42
>>> point.y
21

>>> point.x = 0
>>> point.x
0

In this class, you define two attributes, .x and .y, to represent the point’s coordinates. You can access and update the attributes directly using the dot notation. So, from now on, both attributes are part of your class’s public API.

Now, say that you need to add some validation logic on top of .x and .y. For example, you may need to validate the input values for both attributes. How would you do that? In programming languages like Java or C++, you’d use the getter and setter methods, which translated into Python may look something like this:

class Point:
    def __init__(self, x, y):
        self.set_x(x)
        self.set_y(y)

    def get_x(self):
        return self._x

    def set_x(self, x):
        self._x = self.validate(x)

    def get_y(self):
        return self._y

    def set_y(self, y):
        self._y = self.validate(y)

    def validate(self, value):
        if not isinstance(value, int | float):
            raise ValueError("coordinates must be numbers")
        return value

In this new implementation of Point, you’ve turned .x and .y into non-public attributes by prepending underscores to their names, which now are ._x and ._y. Then, you define getter and setter methods for both attributes. In the setter methods, .set_x() and .set_y(), you insert the validation logic defined in the .validate() method.

Now, you have to use the class as in the following code:

>>> from point_v1 import Point

>>> point = Point(42, 21)

>>> point.get_x()
42
>>> point.get_y()
21

>>> point.set_x(0)
>>> point.get_x()
0
>>> point.set_y("7")
Traceback (most recent call last):
    ...
ValueError: coordinates must be numbers

Your class works differently after the update. Instead of accessing the .x and .y attributes directly, you have to use the getter and setter methods. The validation logic works, which is great, but you’ve broken your class’s API. Your users won’t be able to do something like the following:

>>> point.x
Traceback (most recent call last):
    ...
AttributeError: 'Point' object has no attribute 'x'

Old users of your class will be surprised that their code is broken after updating to your new version of Point. So, how can you avoid this kind of issue? The Pythonic approach is to convert public attributes into properties instead of using getter and setter methods.

You can use the built-in property() function to do this conversion. Here’s how you can keep your Point class’s API unchanged:

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @property
    def x(self):
        return self._x

    @x.setter
    def x(self, value):
        self._x = self.validate(value)

    @property
    def y(self):
        return self._y

    @y.setter
    def y(self, value):
        self._y = self.validate(value)

    def validate(self, value):
        if not isinstance(value, int | float):
            raise ValueError("coordinates must be numbers")
        return value

Point now looks a bit different. It doesn’t have formal getter and setter methods. Instead, it has some methods that are decorated with @property. Yes, the built-in property() function is mostly used as a decorator.

The methods that you decorate with @property are equivalent to getter methods. Meanwhile, the methods that you decorate with the getter’s name plus .setter() are equivalent to setter methods. The cool thing about properties is that you can still use the attributes as regular attributes:

>>> from point_v2 import Point

>>> point = Point(42, 21)

>>> point.x
42
>>> point.y
21

>>> point.x = 0
>>> point.x
0

>>> point.x = "7"
Traceback (most recent call last):
    ...
ValueError: coordinates must be numbers

By turning regular attributes into properties, you can add function-like behavior to them without losing the ability to use them as regular attributes. Properties save you from introducing breaking changes into your code’s public API, so you don’t break your users’ code.

Creating Class and Static Methods: classmethod() and staticmethod()

Classes allow you to define reusable pieces of code that encapsulate data and behavior in a single entity. Usually, you store data in attributes, which are variables defined inside classes. When it comes to behaviors, you’ll use methods, which are functions defined in classes.

In Python, you have three different types of methods:

1. Instance methods, which take the current object as their first argument
2. Class methods, which take the current class as their first argument
3. Static methods, which take neither the current instance nor the current class as arguments

Instance methods need to take the current instance as an argument. By convention, this argument is called self in Python.

To create a class method, you need to decorate the method with the @classmethod decorator. Similarly, to create a static method, you need to decorate the method with the @staticmethod decorator. Both decorators are part of Python’s built-in functions.

A common use case for class methods is to provide multiple constructors for a class. To illustrate how to write a class method, say that you want a Point class that you can construct using either Cartesian or polar coordinates. In this situation, you can do something like the following:

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    @classmethod
    def from_polar(cls, distance, angle):
        return cls(
            x=distance * math.cos(math.radians(angle)),
            y=distance * math.sin(math.radians(angle)),
        )

In this example, the .from_polar() method is a class method. It takes the current class as its first argument, which you typically call cls by convention. The method returns a new instance of the class by computing the Cartesian coordinates from the polar coordinates.

Here’s how you can use this method in practice:

>>> from point import Point

>>> point = Point.from_polar(20, 15)

>>> point.y
5.176380902050415
>>> point.x
19.318516525781366

In this code snippet, you create a new Point instance using the .from_polar() class method. In the example, you call the method on the class rather than on an instance to signal that this is a class method. You can call a class method on an instance of its containing class too.

The third type of method is the static method. A static method doesn’t take the current instance or class as arguments. These methods are like regular functions that you decide to include in a given class for convenience. Functionally, they could also be defined as regular functions in a module.

For example, consider the following Formatter class:

class Formatter:
    @staticmethod
    def as_currency(value):
        return f"${value:,.2f}"

    @staticmethod
    def as_percent(value):
        return f"{value:.2%}"

This class defines two static methods. The first method takes a numeric value and formats it as a currency value. The second method takes a numeric value and expresses it as a percent. You could have defined these methods as regular functions at the module level. However, you’ve defined them in a class as a way to conveniently group them according to how they’ll be used.

You can use this class as in the following examples:

>>> from formatting import Formatter

>>> Formatter.as_currency(1000)
'$1,000.00'

>>> Formatter.as_percent(0.75)
'75.00%'

>>> formatter = Formatter()
>>> formatter.as_currency(1000)
'$1,000.00'

>>> formatter.as_percent(0.8)
'80.00%'