Numeric Literals

Among its basic object types, Python provides integers, which are positive and negative whole numbers, and floating-point numbers, which are numbers with a fractional part (sometimes called floats for verbal economy). Python also allows us to write integers using hexadecimal, octal, and binary literals; offers a complex number type; and allows integers to have unlimited precision—they can grow to have as many digits as your memory space allows. Table 5-1 shows what Python’s numeric types look like when written out in a program as literals or constructor-function calls.

In general, Python’s numeric type literals are straightforward to write, but a few coding concepts are worth highlighting up front:

Integer and floating-point literals

Integers are written as strings of decimal digits. As noted, they have precision (number of digits) limited only by your device’s available memory. You can easily compute 2 raised to the power 1,000,000, though with 300K digits, it may take some time to print (and can’t be converted to a print string today by default, per Chapter 4).

Floating-point numbers have a decimal point and/or an optional signed exponent introduced by an e or E and followed by an optional sign. If you write a number with a decimal point or exponent, Python makes it a floating-point object and uses floating-point (not integer) math when the object is used in an expression. As you’ll learn, mixing a floating-point number with an integer does floating-point math too, after converting the integer up.

Hexadecimal, octal, and binary literals

Integers may be coded in decimal (base 10), hexadecimal (base 16), octal (base 8), or binary (base 2), the last three of which are common in some programming domains. Hexadecimals start with a leading 0x or 0X, followed by a string of hexadecimal digits (0–9 and A–F). Hex digits may be coded in lowercase or uppercase. Octal literals start with a leading 0o or 0O (zero and lowercase or uppercase letter o), followed by a string of octal digits (0–7). Binary literals begin with a leading 0b or 0B, followed by binary digits (0–1).

All of these literals produce integer objects in program code; they are just alternative syntaxes for specifying values. The built-in calls hex(I), oct(I), and bin(I) convert an integer to its representation string in these three bases, and int(str, base) converts a runtime string to an integer per a given base.

Complex numbers

Though used more rarely, Python complex literals are written as realpart+imaginarypart, where the imaginarypart is terminated with a j or J. The realpart is technically optional, so the imaginarypart may appear on its own. Internally, complex numbers are implemented as pairs of floating-point numbers, but all numeric operations perform complex math when applied to complex numbers. Complex numbers may also be created with the complex(real, imag) built-in call.

Coding other numeric types

As you’ll see later in this chapter, there are additional numeric types near the end of Table 5-1 that serve more advanced or specialized roles. You create some of these by calling functions in imported modules (e.g., decimals and fractions), others have literal syntax all their own (e.g., sets), and Booleans are a kind of specialized integer.

Built-in Numeric Tools

Besides the built-in number literals and construction calls shown in Table 5-1, Python provides a set of tools for processing number objects:

Expression operators

+, -, *, /, >>, **, &, %, etc.

Built-in mathematical functions

pow, abs, round, int, hex, bin, etc.

Utility modules

random, math, statistics, etc.

You’ll meet all of these as we go along.

Although numbers are primarily processed with expressions, built-ins, and modules, they also have a handful of type-specific methods today, which you’ll meet in this chapter. Floating-point numbers, for example, have an as_integer_ratio method useful for the fraction number type, and an is_integer method to test if the number is an integer. Integer attributes include a bit_length method that gives the number of bits necessary to represent the object’s value, and as part collection and part number, sets support both expressions and methods too.

Since expressions are the most essential tool for most number types, though, let’s turn to them next.

Mixed Operators: Precedence

As in most languages, in Python, you code more complex expressions by stringing together the operator expressions in Table 5-2. For instance, the sum of two multiplications might be written as a mix of variables and operators:

A * B + C * D

Which raises the question: how does Python know which operation to perform first? The answer to this question lies in operator precedence. When you write an expression with more than one operator, Python groups its parts according to what are called precedence rules, and this grouping determines the order in which the expression’s parts are computed. To denote this, Table 5-2 is ordered by operator precedence:

• Operators lower in the table have higher precedence, and so bind more tightly in mixed expressions. Put another way, operators higher in the table have lower precedence and bind less tightly than those below them.

• Operators in the same row in the table generally group from left to right when combined (except for exponentiation, which groups right to left, and comparisons, which chain left to right).

So, for example, if you write X + Y * Z, Python evaluates the multiplication first (Y * Z) then adds that result to X, because * has higher precedence (is lower in the table) than +. Similarly, in this section’s original example, both multiplications (A * B and C * D) will happen before their results are added because + is above *.

Parentheses Group Subexpressions

You can largely forget about precedence rules if you’re careful to group parts of expressions with parentheses. When you enclose subexpressions in parentheses, you override Python’s precedence rules; Python always evaluates expressions in parentheses first before using their results in the enclosing expressions.

For instance, instead of coding X + Y * Z, you could write one of the following to force Python to evaluate the expression in either desired order:

(X + Y) * Z
X + (Y * Z)

In the first case, + is applied to X and Y first, because this subexpression is wrapped in parentheses. In the second case, the * is performed first (just as if there were no parentheses at all). Generally speaking, adding parentheses in large expressions is a good idea—it not only forces the evaluation order you want, but also aids readability.

Mixed Types Are Converted Up

Besides mixing operators in expressions, you can also mix numeric types. For instance, you can add an integer to a floating-point number:

40 + 3.14

But this leads to another question: what type is the result—integer or floating point? The answer is simple, especially if you’ve used almost any other language before: in mixed-type numeric expressions, operands (the parts of the expression that aren’t operators) are first converted up to the type of the most complicated operand, and then the math is performed on same-type operands. The result is that of the up-converted operands.

For this, Python ranks the complexity of numeric types like so: integers are simpler than floating-point numbers, which are simpler than complex numbers. So, when an integer is mixed with a floating point, as in the preceding example, the integer is converted up to a floating-point value first, and floating-point math yields the floating-point result. See for yourself in your local Python REPL:

>>> 40 + 3.14       # Integer to float, float math/result
43.14

Similarly, any mixed-type expression where one operand is a complex number results in the other operand being converted up to a complex number, and the expression yields a complex result. Conversions also run in equality and magnitude comparisons: 3 == 3.0 is true, but 3 > 3.0 is not.

You can force the issue by calling built-in functions to convert types manually:

>>> int(3.1415)     # Truncates float to integer
3
>>> float(3)        # Converts integer to float
3.0

However, you won’t usually need to do this: because Python automatically converts up to the more complex type within an expression, the results are normally what you want.

While automatic conversions are run for both numeric and comparison operators, keep in mind that they apply only when mixing numeric objects (e.g., an integer and a float) in an expression. In general, Python does not convert across any other type boundaries automatically. Adding a string of digits to an integer, for example, results in an error, unless you manually convert one or the other; watch for an example and rationale when we explore strings in Chapter 7. Equality tests do work on mixed types (e.g., a string is never equal to any integer), but magnitude comparisons do not.

Preview: Operator Overloading and Polymorphism

Although we’re focusing on built-in numbers right now, all Python operators may be overloaded (i.e., implemented) by Python classes and C extension types to work on objects you create. For instance, you’ll see later that objects coded with classes may be added or concatenated with x+y expressions, indexed with x[i] expressions, and so on.

Furthermore, Python itself automatically overloads some operators, such that they perform different actions depending on the type of built-in objects being processed. For example, the + operator performs addition when applied to numbers but performs concatenation when applied to sequence objects like strings and lists. In fact, + can mean anything at all when applied to objects you define with classes.

As we saw in the prior chapter, this property is usually called polymorphism—a term indicating that the meaning of an operation depends on the type of the objects being processed. We’ll revisit this concept when we explore functions in Chapter 16, because it becomes a much more obvious feature in that context.

Variables and Basic Expressions

First of all, let’s do the math to demo some basics. In the following interaction, we first assign two variables (a and b) to integers so we can use them later in a larger expression. Variables are simply names—created by you or Python—that are used to keep track of information in your program. We’ll say more about this in the next chapter, but in Python:

• Variables are created when they are first assigned values.

• Variables are replaced with their values when used in expressions.

• Variables must be assigned before they can be used in expressions.

• Variables refer to objects and need not be declared ahead of time.

In other words, these assignments cause the variables a and b to spring into existence automatically:

$ python3                  # Fire up a REPL
>>> a = 3                  # Name created: no need to declare ahead of time
>>> b = 4

This code also uses comments. Recall from Chapter 3 that in Python code, text after a # mark and continuing to the end of the line is considered to be a comment and is ignored by Python. Comments are one way to write human-readable documentation for your code, and an important part of programming. They describe aspects of the code, salient or subtle, as an aid for others (and you, six months down the road!). In the next part of the book, you’ll also meet a related feature—documentation strings—that attaches docs to objects so it’s available after your code is loaded.

Again, though, because code you type interactively is temporary, you won’t normally write comments in this context. If you’re working along, this means you don’t need to type any of the comment text from the # through to the end of the line in a REPL; it’s not a required part of the statements we’re running this way.

Now, let’s use our new integer objects in expressions. At this point, the values of a and b are still 3 and 4, respectively. Variables like these are replaced with their values whenever they’re used inside an expression, and the expression results are echoed back immediately and automatically when we’re working interactively:

>>> a + 1, a − 1           # Addition (3 + 1), subtraction (3 − 1)
(4, 2)
>>> b * 3, b / 2           # Multiplication (4 * 3), division (4 / 2)
(12, 2.0)                  
>>> a % 2, b ** 2          # Modulus (remainder), power (4 ** 2)
(1, 16)
>>> 2 + 4.0, 2.0 ** b      # Mixed-type conversions
(6.0, 16.0)

Per Chapter 3, the results being echoed back here are tuples of two values because the lines typed at the prompt contain two expressions separated by commas; that’s why the results are displayed in parentheses. More importantly, these expressions work because the variables a and b within them have been assigned values. If you use a different variable that has not yet been assigned, Python reports an error rather than filling in some default value:

>>> c * 2
NameError: name 'c' is not defined

As also previewed in Chapter 3, you don’t need to predeclare variables in Python, but they must have been assigned at least once before you can use them. In practice, this means you have to initialize counters to zero before you can add to them, initialize lists to an empty list before you can append to them, and so on.

Here are two slightly larger expressions to illustrate operator grouping and more about conversions:

>>> b / 2 + a              # Same as ((4 / 2) + 3)
5.0
>>> b / (2 + a)            # Same as (4 / (2 + 3))
0.8

In the first expression, there are no parentheses, so Python automatically groups the components according to its precedence rules—because / is lower in Table 5-2 than +, it binds more tightly and so is evaluated first. The result is as if the expression had been organized with parentheses as shown in the comment to the right of the code. In the second expression, parentheses are added around the + part to force Python to evaluate it first (i.e., before the /).

Also, notice that all the numbers are integers in each of these examples. Python’s / performs true division, which always retains fractional remainders and gives a floating-point result—which is in turn reflected in the result of the whole expression. You can force a fractional result by coding 2.0 instead of 2 but don’t have to. You can also opt to use floor division by coding these examples with // instead of /, and Python will discard decimal digits in the result; because results reflect the types of operands, you’ll get back truncated floating-point for floats:

>>> a, b                   # Same, original values
(3, 4)

>>> b // 2 + a             # Floor division: integer
5
>>> b // (2 + a)           # Truncates fraction (for positives)
0

>>> b // 2.0 + a           # Auto-conversions: floating-point
5.0
>>> b // (2.0 + a)
0.0

You’ll learn more about division later in this section.

Numeric Display Formats

Once you start playing with Python numbers in earnest, the results of some expressions may look a bit odd the first time you see them:

>>> 1.1 + 2.2               # What's up with the 3 at the end?
3.3000000000000003
>>> print(1.1 + 2.2)        # Same for prints
3.3000000000000003

The full story behind this odd result has to do with the limitations of floating-point hardware and its inability to exactly represent some values in a limited number of bits. Python floating-point numbers map to the underling chips on your device and are only as accurate as those chips allow—a physical constraint that can be addressed with add-ons that extend floating-point precision, as well as techniques discussed in the section “Floating-point equality.”

Because computer architecture is well beyond this book’s scope, though, we’ll finesse this by saying that your computer’s floating-point hardware is doing the best it can, and neither it nor Python is in error here. In fact, this is partly a display issue—Python’s floating-point display logic tries to be intelligent and usually shows fewer decimal digits, but occasionally cannot. Our earlier examples gave fewer digits automatically, and you can always force the issue in programs with string formatting:

>>> num = 1.1 + 2.2
>>> num                          # Auto-echoes (and prints)
3.3000000000000003

>>> '%e' % num                   # String-formatting expression
'3.300000e+00'
>>> '%.1f' % num                 # Alternative floating-point format
'3.3'

>>> f'{num:e}', f'{num:.1f}'     # F-strings (see also format method)
('3.300000e+00', '3.3')

The last three tests here employ flexible string formatting, which we will explore in full in the upcoming chapter on strings (Chapter 7). Its results are strings that are typically, but not always, printed to displays or reports.

Comparisons Operators

So far, we’ve been dealing with standard numeric operations (e.g., addition and multiplication), but numbers, like all Python objects, can also be compared. Normal comparisons work for numbers exactly as you’d expect—they compare the relative magnitudes of their operands and return a Boolean result, which we would normally test and take action on in a larger statement and program (e.g., see the intro to if in Chapter 4):

>>> 1 < 2                  # Less than (magnitude)
True
>>> 2.0 >= 1               # Greater than or equal: mixed-type 1 converted to 1.0
True
>>> 2.0 == 2.0             # Equal value
True
>>> 2.0 != 2.0             # Not equal value
False

Notice again how mixed types are allowed in numeric expressions (only); in the second test here, Python compares values in terms of the more complex type, float.

>>> X = 2
>>> Y = 4
>>> Z = 6

>>> X < Y < Z              # Chained comparisons: range tests
True
>>> X < Y and Y < Z
True

>>> X < Y > Z
False
>>> X < Y and Y > Z
False

>>> 1 < 2 < 3.0 < 4
True
>>> 1 > 2 > 3.0 > 4
False

>>> 1 == 2 < 3               # Same as: (1 == 2) and (2 < 3), but not: False < 3!
False      
>>> True is False is True    # Same as: (True is False) and (False is True)
False

>>> 1.1 + 2.2 == 3.3              # Shouldn't this be True?
False
>>> 1.1 + 2.2                     # Close to 3.3, but not exactly: limited precision
3.3000000000000003

>>> int(1.1 + 2.2) == int(3.3)        # OK if convert: see also floor, trunc ahead
True
>>> round(1.1 + 2.2, 1) == round(3.3, 1)
True
>>> import math                       # Import modules to call their functions
>>> math.isclose(1.1 + 2.2, 3.3)      # Within default-but-passable tolerances
True

Division Operators

Python has two division operators introduced earlier, as well as one that’s strongly related. Here’s the whole gang:

X / Y

Called true division, this always keeps remainders in floating-point results, regardless of types.

X // Y

Called floor division, this always truncates fractional remainders down to their floor, regardless of types, and its result type depends on the types of its operands.

X % Y

Called modulus, this returns a division’s remainder, with a result type that varies per operand types. This also does formatting when used on strings, per Chapter 7.

The following demos the two division operators at work:

>>> 10 / 4              # True div: keeps remainder always
2.5
>>> 10 / 4.0            # Same for floats
2.5
>>> 10 // 4             # Floor div: drops remainder always
2
>>> 10 // 4.0           # Same for floats, but type varies
2.0

Notice that the object type of the result for // is dependent on its operand’s types: if either is a float, the result is a float; otherwise, it is an integer. If you want to ensure an integer result, simply wrap the expression in int to convert:

>>> int(10 // 4.0)
2

The related modulus returns the remainder of division with a type to match operands (useful when your code needs to know how much is “left over” after a //) , and the divmod built-in function gives both parts when needed:

>>> 10 % 3, 10 % 3.0    # Remainder of division: (3 * 3) + 1
(1, 1.0)
>>> divmod(10, 3)       # Both parts of division in a tuple
(3, 1)

>>> import math
>>> math.floor(2.5)           # Closest number below value
2
>>> math.floor(-2.5)          # But not truncation for negative!
-3
>>> math.trunc(2.5)           # Truncate fractional part (toward zero)
2
>>> math.trunc(-2.5)          # And is truncation for negative
-2

>>> 5 / 2, 5 / -2             # True division keeps remainders
(2.5, −2.5)

>>> 5 // 2, 5 // -2           # Truncates to floor: rounds to first lower integer
(2, −3)

>>> 5 / 2.0, 5 / -2.0         # Ditto for floats
(2.5, −2.5)

>>> 5 // 2.0, 5 // -2.0       # Though result is float too
(2.0, −3.0)

>>> import math
>>> 5 / −2                    # Keep remainder
−2.5
>>> 5 // −2                   # Floor below result
-3
>>> math.trunc(5 / −2)        # Truncate instead of floor (same as int())
−2

Integer Precision

Python division may come in multiple flavors, but it’s still fairly standard as programming languages go. Here’s something a bit more unusual. As mentioned earlier, Python integers support unlimited size:

>>> 999999999999999999999999999999 + 1
1000000000000000000000000000000

Unlimited-precision integers are a convenient built-in tool. For instance, you can use them to count your country’s national debt in Python without numeric-value overflow (which is, of course, more impressive and resource intensive in some locales than others). More universally, a 2 raised to the power 269 isn’t particularly large, but nearly breaches this page’s width limits, and much larger numbers work sans the safeguards against DOS attacks noted in Chapter 4:

>>> 2 ** 269
948568795032094272909893509191171341133987714380927500611236528192824358010355712

>>> x = 2 ** 1000000
>>> x
ValueError: Exceeds the limit (4300 digits) for integer string conversion; 
use sys.set_int_max_str_digits() to increase the limit

Because Python must do extra work to support the extended precision, integer math is usually substantially slower than normal when numbers grow large. However, if you need the precision, the fact that it’s built in for you to use will likely outweigh its performance penalty.

Complex Numbers

Although less commonly used than the types we’ve been exploring thus far, complex numbers are a distinct core object type in Python. They are typically used in engineering and science applications. If you know what they are, you know why they are useful; if not, consider this section optional reading (until they appear in code you must reuse).

Complex numbers are represented as two floating-point numbers—the real and imaginary parts—and you code them by adding a j or J suffix to the imaginary part. We can also write complex numbers with a nonzero real part by adding the two parts with a +. For example, the complex number with a real part of 2 and an imaginary part of −3 is written 2 + −3j. Here are some examples of complex math at work:

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2 + 1j) * 3
(6+3j)

Complex numbers also allow us to extract their parts as attributes (via attributes real and imag), support all the usual mathematical expressions, and may be processed with tools in the standard cmath module (the complex analogue of the standard math module). Because complex numbers are rare in most programming domains, though, we’ll skip the rest of this story here. Check Python’s language reference manual for additional details.

Hex, Octal, and Binary

As previewed near the start of this chapter, Python integers can be coded in hexadecimal, octal, and binary notation, in addition to the normal base-10 decimal coding we’ve been using so far. The first three of these may at first seem foreign to 10-fingered beings, but some programmers find them convenient alternatives for specifying values, especially when their mapping to bytes and bits is important. We detailed coding rules before; let’s try these out live.

As noted earlier, these other-base literals are simply an alternative syntax for specifying the value of an integer object. For example, the following literals produce normal integers with the specified values. In memory, an integer’s value is the same, regardless of the base we use to specify it in our code:

>>> 0x01, 0x10, 0xFF            # Hex literals: base 16, digits 0-9/A-F
(1, 16, 255)
>>> 0o1, 0o20, 0o377            # Octal literals: base 8, digits 0-7
(1, 16, 255)
>>> 0b1, 0b10000, 0b11111111    # Binary literals: base 2, digits 0-1
(1, 16, 255)

Here, the hex value 0xFF, the octal value 0o377, and the binary value 0b11111111 are all decimal 255. The F digits in the hex value, for example, each mean 15 in decimal and a 4-bit 1111 in binary, and reflect powers of 16. Thus, the hex value 0xFF and others convert to decimal values as follows:

>>> 0xFF, (15 * (16 ** 1)) + (15 * (16 ** 0))     # How hex/binary map to decimal
(255, 255)
>>> 0x2F, (2  * (16 ** 1)) + (15 * (16 ** 0))
(47, 47)
>>> 0xF, 0b1111, (1*(2**3) + 1*(2**2) + 1*(2**1) + 1*(2**0))
(15, 15, 15)

Python prints integer values in decimal (base 10) by default, but it also provides built-in functions that convert integers to other bases’ digit strings formatted per Python-literal syntax—useful when programs or users expect to see values in a given base:

>>> oct(64), hex(64), bin(64)               # Numbers=>digit strings
('0o100', '0x40', '0b1000000')

The oct function converts decimal to octal, hex to hexadecimal, and bin to binary—all as strings. To go the other way, the built-in int function converts a string of digits to an integer, and an optional second argument lets you specify the numeric base—useful for numbers read from files as strings instead of coded in scripts:

>>> 64, 0o100, 0x40, 0b1000000              # Digits=>numbers in scripts and strings
(64, 64, 64, 64)

>>> int('64'), int('100', 8), int('40', 16), int('1000000', 2)
(64, 64, 64, 64)

>>> int('0x40', 16), int('0b1000000', 2)    # Literal forms supported too
(64, 64)

The eval function can also be used to convert digit strings to numbers, because it treats strings as though they were Python code. Therefore, it has a similar effect, but usually runs more slowly—it actually compiles and runs the string as a piece of a program, and it assumes the string being run comes from a trusted source—a clever user might be able to submit a string that deletes files on your machine. In other words, be sparing and careful with this call:

>>> eval('64'), eval('0o100'), eval('0x40'), eval('0b1000000')
(64, 64, 64, 64)

Finally, you can also convert integers to base-specific strings with any of Python’s three string-formatting tools, though you’ll have to take this partly on faith until we reach stings’ full coverage in Chapter 7:

>>> '%o, %x, %#X' % (64, 255, 255)          # Numbers=>digits formatting*3
'100, ff, 0XFF'

>>> '{:o}, {:b}, {:x}, {:#X}'.format(64, 64, 255, 255)
'100, 1000000, ff, 0XFF'
 
>>> f'{64:o}, {64:b}, {255:x}, {255:#X}'    # The newest latest-and-greatest
'100, 1000000, ff, 0XFF'

In this code, o, b, and x format as octal, binary, and hex, respectively, and #X adds a base prefix and uses uppercase. As an aside, you can avoid the repeated inputs in each of these three formatting tools (but you’re probably starting to see why picking just one is generally a good idea—and why feature redundancy is generally a bad idea!):

>>> '%(i)o, %(j)x, %(j)#X' % dict(i=64, j=255)
'100, ff, 0XFF'
>>> '{0:o}, {0:b}, {1:x}, {1:#X}'.format(64, 255)
'100, 1000000, ff, 0XFF'
>>> f'{(i:=64):o}, {i:b}, {(i:=255):x}, {i:#X}'
'100, 1000000, ff, 0XFF'

Before we move on, keep in mind that other-base literals and converters support arbitrarily large integers too. The following, for instance, creates an integer in hex and displays it in decimal and octal and binary with converters:

>>> X = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFF
>>> X
5192296858534827628530496329220095
>>> oct(X)
'0o17777777777777777777777777777777777777'
>>> bin(X)
'0b111111111111111111111111111111111111111111111111111111111 ...and so on... 11111'

Speaking of binary digits, the next section takes us on a tour of tools that process numbers’ individual bits.

Bitwise Operations

Besides the normal numeric operations (addition, subtraction, and so on), Python supports most of the numeric expressions available in the C language. This includes operators that treat integers as strings of binary bits and can come in handy if your Python code must deal with things like network packets, serial ports, or packed binary data produced by or intended for a C program.

We can’t dwell on the fundamentals of Boolean math here—again, those who must use it probably already know how it works, and others can often postpone the topic altogether—but the basics are straightforward. For instance, here are some of Python’s bitwise expression operators at work performing bitwise shift and Boolean operations on integers:

>>> x = 1                # 1 decimal is 0001 in bits
>>> x << 2               # Shift left 2 bits: 0100
4
>>> x | 3                # Bitwise OR (either bit=1): 0001 | 0011
3
>>> x & 3                # Bitwise AND (both bits=1): 0001 & 0011
1

In the first expression, a binary 1 (in base 2, 0001) is shifted left two slots to create a binary 4 (0100). The last two operations perform a binary OR to combine bits (0001|0011 = 0011) and a binary AND to select common bits (0001&0011 = 0001). Such bit-masking operations allow us to encode and extract multiple flags and other values within a single integer.

This is one area where the binary and hexadecimal number support in Python become especially useful—they allow us to code and inspect numbers by bit-strings:

>>> X = 0b0001           # Binary literals
>>> X << 2               # Shift left
4
>>> bin(X << 2)          # Binary digits string
'0b100'

>>> bin(X | 0b0011)      # Bitwise OR: either
'0b11'
>>> bin(X & 0b11)        # Bitwise AND: both
'0b1'

This is also true for values that begin life as hex literals, or undergo base conversions:

>>> X = 0xFF             # Hex literals
>>> bin(X)
'0b11111111'
>>> X ^ 0b10101010       # Bitwise XOR: either but not both
85
>>> bin(X ^ 0b10101010)
'0b1010101'

>>> int('01010101', 2)   # Digits=>number: string to int per base
85
>>> hex(85)              # Number=>digits: Hex digit string
'0x55'

Also in this department, Python integers come with a bit_length method, which allows you to query the number of bits required to represent the number’s value in binary. Sharp-eyed readers might point out that you can often achieve the same effect by subtracting 2 from the length of the bin string using the len built-in function we first used in Chapter 4 (to account for the leading “0b”), though its temporary string result may make it less efficient:

>>> X = 99
>>> bin(X), X.bit_length(), len(bin(X)) - 2
('0b1100011', 7, 7)
>>> bin(256), (256).bit_length(), len(bin(256)) - 2
('0b100000000', 9, 9)

We won’t go into much more detail on such “bit twiddling” here. It’s supported if you need it, but bitwise operations are often not as important in a high-level language such as Python as they are in a low-level language such as C. As a rule of thumb, if you find yourself wanting to flip bits in Python, you should think about which language you’re really coding. As you’ll see in upcoming chapters, Python’s lists, dictionaries, and the like provide richer ways to encode information than bit strings, especially when your data’s audience includes readers of the human variety.

Underscore Separators in Numbers

If you’re finding it hard to read the longer digit strings in this chapter, there’s some good news: as of 3.6, numeric literals in Python can be coded with embedded underscores (“_”) to group digits for easier viewing. These underscores don’t modify number values; Python simply discards them after reading your code. They do, however, work on all the numbers and bases we’ve met, including complex-number parts and float-point decimal digits and can enhance the readability of numeric literals in your scripts. Here’s how they look—with before on the left and after on the right:

>>> 9999999999999 == 9_999_999_999_999                 # Decimal: thousands
True
>>> 0xFFFFFFFF == 0xFF_FF_FF_FF                        # Hex: 8-bit bytes
True
>>> 0o777777777777 == 0o777_777_777_777                # Octal: 9 bits each
True 
>>> 0b1111111111111111 == 0b1111_1111_1111_1111        # Binary: 4-bit nibbles
True
>>> 3.141592653589793 == 3.141_592_653_589_793         # Float: decimal digits
True
>>> 123456789.123456789 == 123_456_789.123_456_789     # Float: both sides
True

While this is a useful feature, you should keep in mind that it’s just skin deep. For example, numbers lose their underscores once read. You can add back comma and underscore separators with the string-formatting method and f-string we’ll explore in Chapter 7, but this is mostly just for display, and the originals are lost:

>>> x = 9_999_998              # Your number with "_"s for digit groupings
>>> x                          # But dropped when read: not in displays
9999998
>>> x + 1                      # Ditto for derived computation results
9999999

>>> f'{x:,} and {x:_}'         # Formatting adds separators, but just for show
'9,999,998 and 9_999_998'

Moreover, Python doesn’t do any sort of sanity checks on underscores, except for disallowing leading, trailing, and multiple-appearance uses. The underscores are really just digit “spacers” that can be used—and misused—arbitrarily:

>>> 99_9                       # No position-error checking provided
999
>>> 1_23_456_7890              # Hmm…
1234567890

>>> _9
NameError: name '_9' is not defined. Did you mean: '_'?
>>> 9_
SyntaxError: invalid decimal literal
>>> 9_9__9
SyntaxError: invalid decimal literal

>>> 9_9_9                      # Syntax oddities checked, semantics not
999
>>> hex(0xf_ff_fff_f_f)        # And Python won't retain your "_"s
'0xffffffff'

Also bear in mind that commas cannot be used in numeric literals you code—despite their similarity, underscores are essentially ignored as documentation, but commas are taken to be tuple item separators if erroneously used:

>>> 12_345_678                 # Underscores are ignored 
12345678
>>> 12,345,678                 # But commas means a tuple!
(12, 345, 678)

Underscores can enhance readability to be sure, but they are largely cosmetic and apply only to large numeric literals in your code—because typical Python programs compute most numbers rather than hardcoding them, this seems likely to be uncommon in practice. A more promising use case is input—string-to-number converters allow underscores too:

>>> int('1_234_567')           # Works in text read from data files too
1234567
>>> eval('1_234_567')          # But does raw-data readability matter?
1234567
>>> float('1_2_34.567_8_90')
1234.56789

But it’s difficult to justify underscores on data alone, given that scripts could simply strip underscores themselves. Like all such tools, use when it makes sense (and don’t be shocked if this crops up in unfair interview questions!).

Other Built-in Numeric Tools

In addition to its core object types, Python also provides both built-in functions and standard library modules for numeric processing. The pow and abs built-in functions, for instance, compute powers and absolute values, respectively. Here’s a brief roundup of common tools in the built-in math module (which contains most of the tools in the C language’s math library), along with a few numeric built-in functions:

>>> import math
>>> math.pi, math.e                               # Common constants
(3.141592653589793, 2.718281828459045)

>>> math.sin(2 * math.pi / 180)                   # Sine, tangent, cosine
0.03489949670250097

>>> math.sqrt(144), math.sqrt(2)                  # Square root
(12.0, 1.4142135623730951)

>>> pow(2, 4), 2 ** 4, 2.0 ** 4.0                 # Exponentiation (power)
(16, 16, 16.0)

>>> abs(-62.0), sum((1, 2, 3, 4))                 # Absolute value, summation
(62.0, 10)

>>> min(3, 1, 2, 4), max(3, 1, 2, 4)              # Minimum, maximum
(1, 4)

The sum function shown here works on a sequence (really, iterable) of numbers, and min and max accept either a collection or individual arguments. There are also multiple ways to drop the decimal digits of floating-point numbers, both for calculations and displays; some of these are richer than previously shown:

>>> math.floor(2.567), math.floor(-2.567)            # Floor: next-lower integer
(2, −3)

>>> math.trunc(2.567), math.trunc(−2.567)            # Truncate: drop digits 
(2, −2)

>>> int(2.567), int(−2.567)                          # Truncate: alternative
(2, −2)

>>> round(2.567), round(2.567, 2), round(2567, -3)   # Round to digits (+/-)
(3, 2.57, 3000)

>>> '%.1f' % 2.567, '{0:.2f}'.format(2.567)          # Format display (Chapter 7)
('2.6', '2.57')

As shown earlier, the last of these produces strings that we would usually print and supports a variety of formatting options. String formatting is still subtly different, though: round rounds and drops decimal digits but still produces a number in memory, whereas string formatting produces a string, not a number:

>>> (1 / 3.0), round(1 / 3.0, 2), f'{(1 / 3.0):.2f}'
(0.3333333333333333, 0.33, '0.33')

Interestingly, there are three ways to compute square roots in Python: using a module function, an expression, or a built-in function (if you’re interested in performance, we will revisit these in an exercise and its solution at the end of Part IV, to see which runs quicker):

>>> import math
>>> math.sqrt(144)              # Module
12.0
>>> 144 ** .5                   # Expression
12.0
>>> pow(144, .5)                # Built-in
12.0

Notice that standard library modules such as math must be imported, but built-in functions such as abs and round are always available without imports. This is because modules are external components, but built-in functions live in an implied namespace that Python automatically searches to find names used in your program. This namespace simply corresponds to the standard library module called builtins, and there is much more about name resolution in the function and module parts of this book; for now, when you hear “module,” think “import.”

The standard library’s statistics and random modules must be imported as well. Both modules provide an array of tools; statistics supports operations commonly found on calculators, and random enables tasks such as picking a random number between 0 and 1 and selecting a random integer between two numbers:

>>> import statistics
>>> statistics.mean([1, 2, 4, 5, 7])        # Average, median
3.8
>>> statistics.median([1, 2, 4, 5, 7])      # And a whole lot more: see its docs
4

>>> import random
>>> random.random()
0.5566014960423105
>>> random.random()              # Random floats, integers, choices, shuffles
0.051308506597373515

>>> random.randint(1, 10)
5
>>> random.randint(1, 10)
9

The random module can also choose an item at random from a sequence, and shuffle a list of items randomly:

>>> random.choice(['Pizza', 'Tacos', 'Tikka', 'Lasagna'])
'Tikka'
>>> random.choice(['Pizza', 'Tacos', 'Tikka', 'Lasagna'])
'Lasagna'

>>> suits = ['hearts', 'clubs', 'diamonds', 'spades']
>>> random.shuffle(suits)
>>> suits
['spades', 'hearts', 'diamonds', 'clubs']
>>> random.shuffle(suits)
>>> suits
['clubs', 'diamonds', 'hearts', 'spades']

Though we’d need additional code to make this more tangible here, the random module can be useful for shuffling cards in games, picking images at random in a slideshow GUI, performing statistical simulations, and much more. We’ll deploy it again later in this book (e.g., in Chapter 20’s permutations case study), but for more details, consult Python’s library manual.

Decimal Objects

First up, is Python’s special-purpose numeric object known formally as Decimal (and informally as decimal). Syntactically, decimals are created by calling a function within an imported standard library module, rather than running a literal expression. Functionally, decimals are like floating-point numbers, but they have a fixed and configurable number of decimal digits. Hence, decimals are fixed-precision floating-point values.

For example, with decimals, we can have a floating-point value that always retains just two decimal digits. Furthermore, we can specify how to round or truncate the extra decimal digits beyond the object’s cutoff. Although it generally incurs a performance penalty compared to normal floating point, decimal is well suited to representing fixed-precision quantities like sums of money and can achieve better numeric accuracy in some contexts.

>>> 0.1 + 0.1 + 0.1 - 0.3                       # Almost zero, but not quite
5.551115123125783e-17

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')

>>> Decimal('0.1') + Decimal('0.10') + Decimal('0.1000') - Decimal('0.30')
Decimal('0.0000')

>>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)
Decimal('2.775557561565156540423631668E-17')

>>> import decimal
>>> decimal.Decimal(1) / decimal.Decimal(7)                     # Default precision
Decimal('0.1428571428571428571428571429')

>>> decimal.getcontext().prec = 4                               # Fixed precision
>>> decimal.Decimal(1) / decimal.Decimal(7)
Decimal('0.1429')

>>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) - Decimal(0.3)   # Closer to 0…
Decimal('1.110E-17')

Fraction Objects

Python’s standard-library fractions module implements a rational number object. It essentially keeps both a numerator and a denominator explicitly, so as to avoid some of the inaccuracies and limitations of floating-point math. Like decimals, fractions do not map as closely to computer hardware as floating-point numbers. This means their performance may not be as good, but it also allows them to provide extra utility in a standard tool where useful.

>>> from fractions import Fraction
>>> x = Fraction(1, 3)                    # Numerator, denominator
>>> y = Fraction(4, 6)                    # Simplified to 2, 3 by gcd

>>> x
Fraction(1, 3)
>>> y
Fraction(2, 3)
>>> print(y)
2/3

>>> x + y
Fraction(1, 1)
>>> x − y                           # Results are exact: numerator, denominator
Fraction(−1, 3)
>>> x * y
Fraction(2, 9)

>>> Fraction('.25')
Fraction(1, 4)
>>> Fraction('1.25')
Fraction(5, 4)

>>> Fraction('.25') + Fraction('1.25')
Fraction(3, 2)

>>> a = 1 / 3                       # Only as accurate as floating-point hardware
>>> b = 4 / 6                       # Can lose precision over many calculations
>>> a
0.3333333333333333
>>> b
0.6666666666666666

>>> a + b
1.0
>>> a - b
-0.3333333333333333
>>> a * b
0.2222222222222222

>>> 0.1 + 0.1 + 0.1 - 0.3           # This should be zero (close, but not exact)
5.551115123125783e-17

>>> from fractions import Fraction
>>> Fraction(1, 10) + Fraction(1, 10) + Fraction(1, 10) - Fraction(3, 10)
Fraction(0, 1)

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')

>>> 1 / 3                           # Normal floating-point
0.3333333333333333

>>> Fraction(1, 3)                  # Numeric accuracy, two ways
Fraction(1, 3)

>>> import decimal
>>> decimal.getcontext().prec = 2
>>> Decimal(1) / Decimal(3)
Decimal('0.33')

>>> (1 / 3) + (6 / 12)
0.8333333333333333

>>> Fraction(1, 3) + Fraction(6, 12)
Fraction(5, 6)

>>> decimal.Decimal(1 / 3) + decimal.Decimal(6 / 12)
Decimal('0.83')

Set Objects

In addition to all the numeric objects we’ve explored, Python has built-in support for sets—an unordered collection of unique and immutable objects that supports operations corresponding to mathematical set theory. Sets straddle the fence between collections and math but lean far enough on the latter side to warrant coverage in this chapter.

By definition, an item appears only once in a set, no matter how many times it is added. Accordingly, sets have a variety of applications, especially in numeric and database-focused work. On the other hand, because sets are collections of other objects, they share some behavior with objects such as lists and dictionaries previewed in Chapter 4. For example, sets are iterable, can grow and shrink on demand, and may contain a variety of object types.

Still, because sets are unordered and do not map keys to values, they are neither sequence nor mapping types; they are a type category unto themselves. Moreover, because sets also tend to be used much less often than pervasive objects like lists and dictionaries, a brief look should suffice for most readers; let’s get started here with the usual REPL tour.

>>> x = set('abcde')                    # Make a set by calling its type/function
>>> y = {99, 'b', 'y', 'd', 1.2}        # Make a set by literal

>>> x 
{'d', 'c', 'e', 'a', 'b'}               # Order is scrambled, displays literal
>>> y
{1.2, 99, 'y', 'd', 'b'}

>>> z = set()                           # Make empty set: {} is empty dictionary
>>> z
set()

>>> z = set([1.2, 'a', 3, 1.2, 'a'])    # Any sequence works, duplicates dropped
>>> z
{'a', 1.2, 3}

>>> {1, *'abc', *[1, 2, 3]}             # Literal star unpacking (Python 3.5+)
{1, 2, 3, 'c', 'b', 'a'}

>>> x = set('abcd')
>>> y = set('bdxy')

>>> x – y                           # Difference: in x, not in y
{'a', 'c'}
 
>>> x | y                           # Union: in either
{'y', 'd', 'x', 'c', 'a', 'b'}
 
>>> x & y                           # Intersection: in both
{'d', 'b'}
 
>>> x ^ y                           # Symmetric difference: not in both
{'y', 'x', 'c', 'a'}
  
>>> x < y, x > y                    # Superset, subset tests
(False, False)

>>> 'd' in x                                      # Membership (sets)
True

>>> 'd' in 'code', 2 in [1, 2, 3]                 # But works on other types too
(True, True)

>>> z = x.intersection(y)                         # Same as x & y
>>> z
{'d', 'b'}
>>> z.add('HACK')                                 # Insert one item
>>> z
{'HACK', 'd', 'b'}
>>> z.update(set(['X', 'Y']))                     # Merge: in-place union
>>> z
{'X', 'HACK', 'd', 'b', 'Y'}
>>> z.remove('b')                                 # Delete one item
>>> z
{'X', 'HACK', 'd', 'Y'}

>>> for item in set('abc'):                       # See Chapter 4 for "for"
        print(item * 3)

aaa
ccc
bbb
>>> {'a', 'b', 'c'} + {'d'}
TypeError: unsupported operand type(s) for +: 'set' and 'set'

>>> S = set([1, 2, 3])
>>> S | set([3, 4])                # Expressions require both to be sets
{1, 2, 3, 4}
>>> S | [3, 4]
TypeError: unsupported operand type(s) for |: 'set' and 'list'

>>> S.union([3, 4])                # But their methods allow any iterable
{1, 2, 3, 4}
>>> S.intersection((1, 3, 5))
{1, 3}
>>> S.issubset(range(-5, 5))       # Subset of range -5...4 series generator
True
>>> S = set([1, 2, 3])
>>> S.intersection_update((1, 2, 5))
>>> S
{1, 2}
>>> 
>>> S |= {1, 2, 4}
>>> S
{1, 2, 4}

>>> S = {1.23}

>>> S.add([1, 2, 3])                   # Only immutable objects work in a set
TypeError: unhashable type: 'list'
>>> S.add({'a':1})
TypeError: unhashable type: 'dict'

>>> S.add((1, 2, 3))
>>> S                                  # No list or dict; tuple, str, numbers OK
{1.23, (1, 2, 3)}

>>> S | {(4, 5, 6), (1, 2, 3)}         # Union: same as S.union(...)
{1.23, (4, 5, 6), (1, 2, 3)}

>>> (1, 2, 3) in S                     # Membership: by complete values
True
>>> (1, 4, 3) in S
False

>>> S.add(frozenset('app'))
>>> S
{1.23, (1, 2, 3), frozenset({'a', 'p'})}

>>> {x ** 2 for x in [1, 2, 3, 4]}         # Make a new set with a comprehension
{16, 1, 4, 9}

>>> {x for x in 'py3X'}                    # Same as: set('py3x')
{'p', 'X', '3', 'y'}
 
>>> {c * 4 for c in 'py3X'}                # Set of collected expression results
{'yyyy', '3333', 'XXXX', 'pppp'}
>>> {c * 4 for c in 'py3X' + 'py2X'}       # Expressions work on both sides
{'yyyy', '3333', 'XXXX', '2222', 'pppp'}

>>> S = {c * 4 for c in 'py3X'}            # All set ops work on results
>>> S | {'zzzz', 'XXXX'}
{'yyyy', '3333', 'XXXX', 'pppp', 'zzzz'}
>>> S & {'zzzz', 'XXXX'}
{'XXXX'}

>>> L = [1, 2, 1, 3, 2, 4, 5]
>>> set(L)
{1, 2, 3, 4, 5}
>>> L = list(set(L))                                  # Removing duplicates
>>> L
[1, 2, 3, 4, 5]

>>> list(set(['yy', 'cc', 'aa', 'xx', 'dd', 'aa']))   # But order may change
['xx', 'cc', 'yy', 'aa', 'dd']

>>> set([1, 3, 5, 7]) - set([1, 2, 4, 5, 6])          # Find list differences
{3, 7}
>>> set('abcdefg') - set('abdghij')                   # Find string differences
{'c', 'e', 'f'}
>>> set('code') - set(['t', 'o', 'e'])                # Find differences, mixed
{'c', 'd'}

>>> L1, L2 = [1, 3, 5, 2, 4], [2, 5, 3, 4, 1]
>>> L1 == L2                                          # Order matters in sequences
False
>>> set(L1) == set(L2)                                # Order-neutral equality
True
>>> sorted(L1) == sorted(L2)                          # Similar but results ordered
True
>>> 'code' == 'edoc', set('code') == set('edoc'), sorted('code') == sorted('edoc')
(False, True, True)

>>> engineers = {'pat', 'ann', 'bob', 'sue'}
>>> managers  = {'sue', 'tom'}

>>> 'pat' in engineers                   # Is pat an engineer?
True

>>> engineers & managers                 # Who is both engineer and manager?
{'sue'}

>>> engineers | managers                 # All people in either category
{'ann', 'sue', 'pat', 'tom', 'bob'} 

>>> engineers - managers                 # Engineers who are not managers
{'pat', 'ann', 'bob'}

>>> managers - engineers                 # Managers who are not engineers
{'tom'}

>>> engineers > managers                 # Are all managers engineers? (superset)
False

>>> {'sue', 'bob'} < engineers           # Are both engineers? (subset)
True

>>> (managers | engineers) > managers    # All people is a superset of managers
True

>>> managers ^ engineers                 # Who is in one group but not both?
{'ann', 'pat', 'tom', 'bob'}

Boolean Objects

Though somewhat gray, the Python Boolean type, bool, is arguably numeric in nature because its two values, True and False, are just customized versions of the integers 1 and 0 that print themselves differently. Python treats 1 and 0 as true and false like many programming languages, but its True and False makes Boolean roles more explicit. Although that’s all some programmers may need to know, let’s briefly reveal this type’s forgery.

To represent truth values, Python has an explicit Boolean type called bool, from which the objects preassigned to built-in names True and False are made. That is, True and False are instances of bool, which is in turn just a subclass (in the object-oriented sense) of the built-in integer type int. True and False behave exactly like the integers 1 and 0, except that they have customized printing logic—they print themselves as the words True and False, instead of the digits 1 and 0. bool accomplishes this by redefining str and repr string formats (introduced earlier in this chapter) for its two objects, and all logical tests yield True or False for their results.

Because of this customization, Boolean expressions typed at the interactive prompt prints results as the words True and False instead of the less obvious 1 and 0. In addition, Booleans make truth values more apparent in your code. For instance, an infinite loop can be coded as while True: instead of the less intuitive while 1:, and flags can be initialized more clearly with flag = False. We’ll discuss these statements further in Part III.

Again, though, for most practical purposes, you can treat True and False as though they are predefined variables set to integers 1 and 0. This implementation can lead to curious results, though; because True is just the integer 1 with a custom display format, True + 4 yields integer 5 in Python:

>>> type(True)               # True is a bool
<class 'bool'>
>>> isinstance(True, int)    # As well as an int
True
>>> True == 1                # Same value
True
>>> True is 1                # But a different object: see the next chapter!
False
>>> True or False            # Same as: 1 or 0
True
>>> True + 4                 # (Hmmm)
5

Since you probably won’t come across an expression like the last of these in real Python code, you can safely ignore any of its deeper metaphysical implications. We’ll revisit Booleans in Chapter 9 to define Python’s notion of truth, and again in Chapter 12 to see how Boolean operators like and and or work.