Getting the Absolute Value of a Number:abs()

Theabsolute value ormodulus of areal number is its non-negative value. In other words, the absolute value is the number without itssign. For example, the absolute value of-5 is5, and the absolute value of5 is also5.

Python’s built-inabs() function allows you to quickly compute the absolute value or modulus of anumber:

>>>fromdecimalimportDecimal>>>fromfractionsimportFraction>>>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 theabs() 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(incomeforincomeintransactionsifincome>0)>>>expenses=abs(...sum(expenseforexpenseintransactionsifexpense<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 theabs() 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 calleddivmod() that takes two numbers as arguments andreturns a tuple with thequotient andremainder 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), whereq is usuallymath.floor(a / b), but may be1 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 thedivmod() function:

>>>defhh_mm_ss(milliseconds):...seconds=round(milliseconds/1000)...minutes,seconds=divmod(seconds,60)...hours,minutes=divmod(minutes,60)...returnf"{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 usedivmod() 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 usedivmod() 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() andmax()

Sometimes, you need to find thesmallest andlargest values in aniterable or in a series of values. These can be common computations in programming, and Python has built-in functions for them.

Themin() function allows you to find the minimum value in an iterable, while themax() 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 callediterable and return the minimum and maximum values, respectively. They also take two optionalkeyword-only arguments:

Here are some quick examples of how to use themin() andmax() 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 usemin() andmax() with a list of numbers. You can also use these functions with a series ofpositional arguments.

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

Computing Powers:pow()

When you need to computepowers in your code, you can use the built-inpow() 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 callpow(), you getbase to the power ofexp. With these two arguments,pow() is equivalent to something likebase**exp:

>>>pow(2,8)256>>>2**8256

This operation computes2 to the power of8, which is256. This is equivalent to a power operation with the**operator, which you’ll find more often in real-world code.

Themod argument allows you to do something likepow(base, exp) % mod but computed more efficiently:

>>>importtimeit>>>base=2>>>exp=1000000>>>mod=1000000>>>timeit.timeit(..."pow(base, exp, mod)",globals=globals(),number=10...)*10000.021042011212557554>>>timeit.timeit(..."pow(base, exp) % mod",globals=globals(),number=10...)*100061.956208024639636

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

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

Rounding Numbers:round()

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

The signature ofround() is shown in the code below:

round(number[,ndigits])

In this signature,number is typically a floating-point number, whilendigits 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:

>>>frommathimportpi>>>pi3.141592653589793>>>round(pi,2)3.14>>>round(pi,4)3.1416>>>round(pi,6)3.141593

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

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

>>>round(1.5)2>>>round(2.5)2

In these two examples, theround() function rounds1.5 up to2 and2.5 down to2. This is becauseround() rounds to the closest multiple of10 to the power minusndigits. If two multiples are equally close, rounding is done toward the even choice. Thisrounding half to even strategy helps mitigate rounding bias. That’s why2.5 rounds to2 rather than3.

Calculating Totals:sum()

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

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

sum(iterable[,start=0])

You can callsum() with the following two arguments:

When you callsum(), the function internally addsstart plus the values initerable. The items in the inputiterable are usually numeric values. However, you can also use lists or tuples. Thestart argument can accept a number, list, or tuple, depending on what youriterable contains.

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

>>>sum([])0>>>sum([1,2,3,4,5])15>>>sum([1,2,3,4,5],100)# As a positional argument115>>>sum([1,2,3,4,5],start=100)# As a keyword argument115>>>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 callsum() with an empty iterable, you get0 as a result because that’s the default value ofstart. Calling the function with a list of values returns the total sum of the provided values.

If you want to use astart value other than0, 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 usesum() to concatenate lists and tuples. Note that for this trick to work, you need to setstart to the appropriate object. If you want to concatenate lists, thenstart 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 usingsum() 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:

defmean(values):try:returnsum(values)/len(values)exceptZeroDivisionError:raiseValueError("mean() arg shouldn't be empty")fromNone

In thismean() function, you usesum() 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(), andhex()

Integernumbers are pretty useful in programming. Python has a built-in data type calledint that represents integers. When working with integers, sometimes you need to express them in different bases like2,8, or16. You may also need to convert strings or other numeric types to integers.

For the latter task, you can use the built-inint() 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() returns0. This behavior is especially useful when you need a factory function for classes likedefaultdict from thecollections 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 useint() to convert abinary,octal, orhexadecimal 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 useint() 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 thebase argument to the appropriate base, which is2 for binary numbers. Next, you do similar conversions with octal and hexadecimal strings. Again, you have to setbase to the appropriate value.

Thebin(),oct(), andhex() 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 tobin(),oct(), andhex(). As a result, you get the string representation of the input value in binary, octal, and hexadecimal format, respectively.

Manipulating Other Numbers:float() andcomplex()

Python has basic built-in types to representfloating-point andcomplex numbers. These types have associated built-in functions for conversion purposes. So, for floating-point numbers, you have thefloat() function, and for complex numbers you havecomplex().

Here are the signatures of both functions:

float(number=0.0)complex(real=0,imag=0)complex(string)

Thefloat() 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() returns0.0. With integer numbers, it returns the equivalent floating-point number with0 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.

Thecomplex() 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 ofcomplex() 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 callcomplex() with numeric values, resulting in a complex number. Note that Python uses aj to define the imaginary part.

The second signature ofcomplex() 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 withcomplex(), 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() andrepr()

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

1. str()
2. repr()

With thestr() 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 usestr() without an argument to create an empty string. In the other examples, you get strings withuser-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 thestr.join() method, which only accepts iterables of strings. In this case, you can do something like the following:

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

In this example, you use agenerator 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-inrepr() function gives you adeveloper-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 withrepr() is the same as the one you get with thestr() function.

To see the difference betweenstr() andrepr(), consider the following example that uses thedatetime module:

>>>importdatetime>>>today=datetime.datetime.now()>>>repr(today)'datetime.datetime(2024, 7, 1, 12, 38, 53, 180208)'>>>str(today)'2024-07-01 12:38:53.180208'

Therepr() method gives you a developer-friendly string representation of thedatetime 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 callingstr() should aim to be readable and informative for end users.

Processing Boolean Values:bool()

Python’s built-inbool() function allows you to determine the truth value of any Python object. It’s a predicate function because it always returnsTrue orFalse. To figure out if an object isfalsy, in other words, whetherbool() returnsFalse when applied to the object, Python uses the following internal rules:

• Constants that are defined to be false:None andFalse
• 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 consideredtruthy 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 howbool() 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 callbool() without an argument and getFalse 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 usebool() when your code explicitly requires a Boolean value instead of a different object.

As an example of usingbool(), say that you have the following implementation of astack data structure:

classStack:def__init__(self,items=None):self.items=list(items)ifitemsisnotNoneelse[]defpush(self,item):self.items.append(item)defpop(self):returnself.items.pop()def__bool__(self):returnbool(self.items)

In this example, yourStack class implements the.__bool__() special method to support Boolean operations on its objects. This method guarantees that when a givenStack object is empty, thebool() function returnsFalse andTrue otherwise. Here’s an example:

>>>fromstackimportStack>>>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 tobool(), you getFalse. Then, you push a value into the stack and callbool() again. This time, you getTrue because the stack isn’t empty anymore.

Encoding Strings:ord() andchr()

Characterencoding is an important topic in most programming languages. In Python, strings use theUnicode characters set by default. Each Unicode character has an associatedcode point, which is an integer number. To get the code point of a given character, you can use the built-inord() 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 theord() 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:

>>>defis_uppercase(text):...forcharintext:...ifnot(65<=ord(char)<=90):...returnFalse...returnTrue...>>>is_uppercase("HELLO")True>>>is_uppercase("Hello")False

In this function, you useord() to determine whether the characters in a string are between65 and90, 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-inchr() function:

>>>chr(65)'A'>>>chr(90)'Z'>>>chr(120)'x'>>>chr(241)'ñ'>>>chr(38)'&'

Thechr() function does the opposite operation oford(). It allows you to find the code point associated with a specific character.

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

Creating Bytes and Byte Arrays:bytes() andbytearray()

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.

Thebytes data type isimmutable, while thebytearray type ismutable. To create objects derived from these data types, you can use the built-inbytes() andbytearray() functions.

Thebytes() andbytearray() 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 abytes literal as an argument. These literals are similar to string literals, but they start with ab and only acceptASCII characters.

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

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

Finally, theerrors 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 thebytes() andbytearray() functions with erroneous data.

Here are a few examples of using thebytes() andbytearray() 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 createbytes andbytearray objects usingbytes literals, and strings with the correct encoding as an argument. Note that you can call thebytes() function with no arguments to create an emptybytes 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 usebytes() becausebytearray() would work similarly. The only difference is thatbytes() returns immutable objects whilebytearray() 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 theerrors argument is"strict". That’s why you get aUnicodeEncodeError exception in the first example above.

Then you seterrors to"ignore" so that Python ignores any encoding error. In this case, theñ andŁ characters are removed. If you seterrors 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() andtuple()

Python’slist 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’stuple 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-inlist() andtuple() functions allow you to createlist andtuple objects.

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

list([iterable])

Note that the square brackets arounditerable mean that the argument isoptional, so the brackets aren’t part of the syntax.

Here are a few examples of usinglist() to createlist 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 calllist() 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.

Thelist() 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 withlist(), 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. Thetuple() function allows you to create tuples on the fly. Here’s the signature:

tuple([iterable])

The square brackets arounditerable mean that the argument isoptional, so the brackets aren’t part of the syntax.

Consider the following examples of usingtuple() 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 usetuple() 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 intotuple(), you get a tuple of characters.

In the third example, you usetuple() 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-indata 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: thedict() function.

Thedict() 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 thedict() 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 thedict() 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 ajane 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() andfrozenset()

Python’sset is a built-in data type for creating collections of unique andhashable objects, typically calledelements ormembers. In Python, sets support theoperations defined for mathematical sets, includingunion,difference,symmetric difference, and others.

Python has two types of sets:

1. set
2. frozenset

The difference between these two data types is thatset objects are mutable, andfrozenset objects are immutable.

As with other data types, Python also provides built-in functions for creating sets and frozen sets. You’ll have theset() andfrozenset() 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 callset() andfrozenset() 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 theset() 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-inlen() function.

Thelen() 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 usinglen() 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 uselen() 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 uselen() with a dictionary as an argument. In this case, you get the number of key-value pairs in the input dictionary.

Note thatlen() returns0 when you call it with empty containers:

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

In these examples, you uselen() with an empty string, tuple, and list. In all cases, you get0 as a result.

Thelen() 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() andsorted()

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-inreversed() function.

Thereversed() function takes an iterable as an argument and returns aniterator thatyields 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 callreversed() with a list of numbers. The function returns a reverse iterator. To display its content, you can use thelist() function to build a list from the iterator.

Similarly, when you need to sort the values in an iterable, you can use thesorted() 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 thekey andreverse arguments, which have the following meanings:

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

Here are a few examples of usingsorted() 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]

Unlikereversed(), thesorted() function always returns a list object rather than an iterator. In the first example, you use a string as an argument tosorted() 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 thereverse argument toTrue and get the list of numbers sorted in reverse order.

Finally, thekey 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=lambdapoint:point[0])[(1, 2), (2, 1), (3, 1), (4, 0)]>>>sorted(points,key=lambdapoint:point[1])[(4, 0), (3, 1), (2, 1), (1, 2)]

In the first highlighted line, you use alambda function that takes a point as an argument and returns its first coordinate. This example would produce the same result if you callsorted() withoutkey because of the way Pythoncompares tuples. In the second highlighted line, thelambda 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() andany()

Sometimes, you may need to determine whether all the items in an iterable are true. To do this, Python has the built-inall() 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-inany() function.

The signature ofall() andany() are shown below:

all(iterable)any(iterable)

Both functions take an iterable of objects as an argument. Theall() function returnsTrue when all the items in the input iterable are true andFalse when at least one item is false.

Here are a few examples of howall() 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 useall() with a list of numbers. The first list contains integer values different from0, which Python considers true. So,all() returnsTrue. Then, in the second example, you add a0 to the list, andall() returnsFalse 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, soall() returnsFalse. Finally, you pass a list with two non-empty strings, andall() rerunsTrue.

You may find several use cases forall() in real-world code. Perhaps passing a generator expression as an argument toall() 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 useall() like in the following code:

>>>numbers=[10,5,6,4,7,8,18]>>># Between 0 and 10>>>all(0<=x<=10forxinnumbers)False>>># Between 0 and 20>>>all(0<=x<=20forxinnumbers)True

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

Theall() function checks if all the generated values areTrue. If that’s the case, then you getTrue. On the other hand, if at least one of the generated values isFalse, then you getFalse.

In contrast toall(), theany() function returnsTrue if at least one item is true andFalse if all the items are false. So, you can useany() when you need to determine if at least one item in an iterable is true.

Here are a couple of examples of usingany() 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() returnsFalse. In the second example, you add the number42 to the end of the input list. Because42 is truthy,any() returnsTrue.

Again, just likeall(), theany() 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()forletterin"hello, world!")False>>>any(letter.isupper()forletterin"Hello, World!")True

In these examples, you use thestr.isupper() method to determine whether a letter is in uppercase. This method returnsTrue orFalse, so you get an iterable of Boolean values. The job ofany() is to determine if any of these values is true.

In the first example, you have no uppercase letters, soany() returnsFalse. In the second example, you have an uppercaseH, soany() returnsTrue.

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-inrange() 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]

Therange() function returns arange object rather than a list. If you want to check the values in a concrete range, then you can wrap it in a call tolist(), 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 from0 to999999. If you want to see it in action, pass it tolist(). You’ll get a terminal window full of numbers!

The built-inrange() 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 at0 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 ofstep, which is1. That’s what you do in the first example, which builds a range of consecutive integers from1 to11. Again,11 isn’t included in the final range because it’s the value at whichrange() stops issuing values.

In the second example, you create arange that starts at10 and goes up to101 with a step of10.

You can also use negative values for the arguments ofrange(). 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 firstrange contains consecutive negative numbers from-10 up to0. The secondrange counts backward from100 to0 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_inrange(3):...print("Beep")...BeepBeepBeep

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 ofrange objects in Python is to use them as a way to loop over an existing iterable:

>>>letters=["a","b","c","d"]>>>forindexinrange(len(letters)):...print(index,letters[index])...0 a1 b2 c3 d

This kind offor loop isn’t the best example of a Pythonic construct. It usesrange() 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 Pythonicfor 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 Pythonfor loops will look something like the following:

>>>colors=["red","orange","yellow","green"]>>>forcolorincolors:...print(color)...redorangeyellowgreen

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:

>>>forindexinrange(len(colors)):...print(index,colors[index])......0 red1 orange2 yellow3 green4 blue5 indigo6 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-inenumerate() function.

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

>>>forindex,colorinenumerate(colors):...print(index,color)...0 red1 orange2 yellow3 green4 blue5 indigo6 violet

This loop is readable and explicit. Theenumerate() 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 is0 because that’s the usual start value of indices in programming. However, in some situations, using a different starting point, like1, can be convenient.

To illustrate how to use thestart argument, say that you’re building atext-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 useenumerate() as in the code below:

>>>deflist_menu(options):...print("Main Menu:")...forindex,optioninenumerate(options,start=1):...print(f"{index}.{option}")...>>>list_menu(["Open","Save","Settings","Quit"])Main Menu:1. Open2. Save3. Settings4. Quit

From the end user’s perspective, starting the menu list at1 is the natural way to go. You can achieve this effect by settingstart to1 in the call toenumerate(). Now, the menu starts at1 instead of0.

Extracting Slices or Portions of Sequences:slice()

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

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

Theslice() function returns aslice object representing the set of indices specified byrange(start, stop, step). The arguments here have a similar meaning as in therange() 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 at1 and go up to the end of the list with a step of2. 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 of2. With this slice, you get a list of odd numbers.

Note that in most Python code, you won’t see or useslice() 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 astart index, then it defaults to the beginning of the list.

Zipping Iterables for Parallel Iteration:zip()

Python’s built-inzip() 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-inzip() 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=["*","/","+"]>>>forcharactersinzip(letters,numbers,operators):...print(characters)...('a', 1, '*')('b', 2, '/')('c', 3, '+')>>>forl,n,oinzip(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 fromzip(). 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 ofzip() 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 usingzip() and pass the resulting tuples to thedict() function to create a dictionary.

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

If you setstrict toTrue, then you’ll get aValueError 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 ofstrict and get five tuples because the shortest range only has five values. In the second example, you setstrict toTrue. This time, you get an error because the input ranges don’t have the same number of values.

Building and Consuming Iterators:iter() andnext()

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

Python has two built-in functions that can help you out when working with iterators. Theiter() function allows you to build an iterator from an iterable, and thenext() 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 theiter() function to create an iterator object from an existing list of colors. Unlike iterables, iterators support thenext() 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 aStopIteration exception. Python internally uses this exception to stop the iteration process in afor 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 ofiter() :

iter(iterable)iter(object,sentinel)

In the first signature,iterable represents any iterable type. In the second signature, theobject argument must be acallable. 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 acommand-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 theiter() function:

>>>defread_user_input():...print("Enter word (type 'done' to finish):")...forwordiniter(input,"done"):...print(f"Processing word: '{word}'")...>>>read_user_input()Enter word (type 'done' to finish):PythonProcessing word: 'Python'ProgrammingProcessing word: 'Programming'IteratorsProcessing word: 'Iterators'done

In the highlighted line, you useiter() with two arguments. For the first argument, you use the built-ininput() 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 callinput() for you and raise aStopIteration 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 thenext() function, you’ll also have two different signatures that looks something like this:

next(iterator)next(iterator,default)

Again, you’ve seen how to usenext() with an iterable as its unique argument. Now, you can focus on using the second signature. In this case, you have a second argument calleddefault. 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 usenext() to consume the iterator one number at a time. Afternext() has consumed the entire iterator, you get0 as a result because that’s the value you passed todefault, the secondpositional argument. Successive calls to the function will return0 as well.

Filtering and Mapping Iterables:filter() andmap()

Have you heard aboutfunctional 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 observableside 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-infilter() andmap() functions.

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

The signature offilter() 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:

Thefunction argument is adecision function, also known as afiltering function. It provides the criteria for deciding whether to keep a given value.

In practice,filter() appliesfunction to all the items initerable. Then, it creates an iterator that yields only the items that meet the criteria thatfunction checks. In other words, it yields the items that makefunction returnTrue.

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

>>>numbers=[1,3,10,45,6,50]>>>list(filter(lambdan:n%2==0,numbers))[10, 6, 50]

In this example, thelambda function takes an integer and returnsTrue if the input value is an even number andFalse otherwise. The call tofilter() applies thislambda function to the values innumbers and filters out the odd numbers, returning the even numbers. Note that you use thelist() function to create a list from the iterator thatfilter() returns.

Themap() function is another common tool in functional programming. This function allows you to apply atransformation function to all the values in an iterable.

Python’smap() has the following signature:

map(function,iterable,*iterables)

Themap() function appliesfunction to each item initerable in a loop and returns a new iterator that yields transformed items on demand.

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

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

To illustrate howmap() 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 themap() 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-inpow() function as the first argument tomap(). As you already learned,pow() takes a base and an exponent as arguments and returns the power. Then, you pass the bases and exponents tomap() so that it computes the desired powers.

Accepting Input From the User:input()

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

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

input([prompt])

The square brackets aroundprompt 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 usinginput(), 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:

fromrandomimportrandintLOW,HIGH=1,10secret_number=randint(LOW,HIGH)clue=""whileTrue:guess=input(f"Guess a number between{LOW} and{HIGH}{clue} ")number=int(guess)ifnumber>secret_number:clue=f"(less than{number})"elifnumber<secret_number:clue=f"(greater than{number})"else:breakprint(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-ininput() 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:

$pythonguess.pyGuess a number between 1 and 10  2Guess a number between 1 and 10 (greater than 2) 3Guess a number between 1 and 10 (greater than 3) 8Guess a number between 1 and 10 (less than 8) 6You 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. Theinput() 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-inopen() function for these purposes. You typically use theopen() function in awith statement.

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

applebananacherryorangemango

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:

>>>withopen("fruits.txt")asfile:...print(file.read())...applebananacherryorangemango

In thiswith statement, you callopen() with the filename as an argument. This call opens the file for reading. Theopen() function returns afile object, which thewith statement assigns to thefile variables with theas specifier.

Theopen() 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 aremode andencoding.

Here’s a list of allowedmode 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:

>>>withopen("hello.txt","w")asfile:...file.write("Hello, World!")...13

In this example, you open a file calledhello.txt so you can write text to it. In the code block of thewith 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 get13 on the screen.

After running the code, you’ll have thehello.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 theencoding 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 toencoding:

>>>withopen("hello.txt","w",encoding="utf-8")asfile:...file.write("Hello, Pythonista!")...13>>>withopen("hello.txt","r",encoding="utf-8")asfile:...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 isbuffering rather thanencoding, and if you don’t use the explicit name, then you get aTypeError 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-inprint() function, which is a fundamental tool in Python programming.

Theprint() function has the following signature:

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

Callingprint() 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 callprint(), it takes the inputobjects, converts them into strings, joins them usingsep, and appendsend. If you callprint() with no argument, then it printsend. Note that the argumentssep,end,file, andflush are keyword arguments.

Here are a few examples of how to use theprint() 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 callprint() with no arguments, thenend 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 bysep, and a newline is added at the end.

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

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

>>>withopen("hello.txt",mode="w")astext_file:...print("Hello, World!",file=text_file)...

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

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

You can set theflush argument toTrue if you want your code’s output to display in real time. If you keepflush at its default value ofFalse, 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 usingflush is when you need to create a progress bar for a CLI application. Consider the following function:

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

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

>>>fromtimeimportsleep>>>fromprogressimportprogress>>>forpercentinrange(101):...sleep(0.2)...progress(percent)...[###########                   ] 38%

This loop callsprogress() 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 stringinterpolation andformatting, includingf-strings and thestr.format() method. These tools take advantage of Python’sstring formatting mini-language, which allows you to nicely format your strings using a dedicated syntax.

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

format(value,format_spec="")

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

Consider the following examples of using theformat() function:

>>>importmath>>>fromdatetimeimportdatetime>>>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 of30 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-inproperty() function allows you to createmanaged attributes in your classes. Managed attributes, also known asproperties, have an associated value and an internal implementation or function-like behavior.

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

>>>classPoint:...def__init__(self,x,y):...self.x=x...self.y=y...>>>point=Point(42,21)>>>point.x42>>>point.y21>>>point.x=0>>>point.x0

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 publicAPI.

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 likeJava orC++, you’d use the getter and setter methods, which translated into Python may look something like this:

classPoint:def__init__(self,x,y):self.set_x(x)self.set_y(y)defget_x(self):returnself._xdefset_x(self,x):self._x=self.validate(x)defget_y(self):returnself._ydefset_y(self,y):self._y=self.validate(y)defvalidate(self,value):ifnotisinstance(value,int|float):raiseValueError("coordinates must be numbers")returnvalue

In this new implementation ofPoint, you’ve turned.x and.y intonon-public attributes by prependingunderscores to their names, which now are._x and._y. Then, you definegetter 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:

>>>frompoint_v1importPoint>>>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.xTraceback (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 ofPoint. 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-inproperty() function to do this conversion. Here’s how you can keep yourPoint class’s API unchanged:

classPoint:def__init__(self,x,y):self.x=xself.y=y@propertydefx(self):returnself._x@x.setterdefx(self,value):self._x=self.validate(value)@propertydefy(self):returnself._y@y.setterdefy(self,value):self._y=self.validate(value)defvalidate(self,value):ifnotisinstance(value,int|float):raiseValueError("coordinates must be numbers")returnvalue