What Is a Variable?

A variable is an area of memory in which you can store data. When you create a variable, you give it a name that enables you to access it to retrieve or change its contents. When your code runs, Python allocates a space in memory for each variable.

For example, you might create a variable called name to store an employee’s name (A). The name would normally be a string of text characters, such as Anna Connor or Bill Ramirez, so the value would receive the str data type, which Python uses for strings. Similarly, you might create a variable called age to store the employee’s age in years as a whole number (B). That value would be an integer, so Python would assign the value the int data type that it uses for integers. Or you might create a variable called isOnProbation to store the employee’s probation status (C). This variable would store the value True or the value False, and Python would assign the value the bool data type that it uses for Boolean values.

A Variable Does Not Have a Data Type, But Its Value Does

In Python, variables themselves do not have data types, so you do not specify the data type when you create a variable. Instead, the value assigned to the variable has a type. So instead of, say, creating a variable and giving it the int data type, which is for integers, you would create a variable and assign data of the int data type to it.

This treatment of variables is called dynamic typing and is different from various other programming languages that enable — or require — you to give each variable a specific data type, a practice called static typing. For example, Microsoft’s Visual Basic programming language encourages you to declare each variable explicitly and assign a data type. For instance, Dim intAge As Integer “dimensions” — creates — a variable called intAge that has the Integer data type and will accept only integer data. Such explicit declarations prevent you from putting the wrong type of data in a variable — trying to do so causes an error — and from overwriting the variable unintentionally by using the same name later in your code.

Creating a Variable and Assigning Data to It

In Python, you create a variable and assign data to it in a single statement. For example, consider the following line:

price = 125

This line (A) declares a variable called price and initializes it by assigning the value 125 to it. This value is an integer, a number with no decimal component, so Python gives it the int data type.

You can then change the value if needed, as in the following line:

price = 250

This line (B) assigns the value 250 to the price variable.

You can also assign data of a different data type to the price variable. For example, the following line (C) assigns a string value:

price = "moderate"

Because the price variable does not have a static data type, it accepts the string value without comment.

However, some IDEs display a warning when your code contains this kind of change, because it could represent an error, as a programmer would not normally change the data type contained in a variable.

Seeing What Data and Data Type a Variable Contains

To see what data a variable contains, you can use the print command to display the contents to the console. For example, the following line (A) displays the contents of the price variable:

print(price)

The print command works fine for values that are text or can easily be interpreted as text, but trying to print a variable containing binary data — for example, an image — will usually cause problems.

To see what data type the value assigned to a variable has, you can use the type command with the variable’s name. For example, the following line (B) displays the data type of the value assigned to the price variable:

type(price)

This command returns the value’s class, such as <class 'int'> for the int data type or <class 'str'> for the str data type.

Understanding How Python Builds on the C Programming Language

The Python programming language is primarily implemented using C, a long-standing and robust programming language that is still widely used across many industries. C is called a low-level programming language, which means that it can interface directly with hardware features, lending itself to software and operating-system development. C is relatively easy to understand but extremely hard to master.

Python is a high-level programming language and includes many built-in features that C does not natively support, giving you an easier way to harness some of the power of C to develop solutions rather than using C directly. Python’s extensive feature set and capability to run well on many platforms contributes to its great versatility.

Because Python is built on C, Python’s data types are constructed using combinations of C’s data types. For example, Python includes a data type called set that enables you to store multiple pieces of information in a single variable — a capability that C itself does not directly provide. Furthermore, some of Python’s more complex data types are constructed using simpler Python data types.

Understanding the Numeric Data Types

Python provides three main numeric types for handling different kinds of numeric data:

• int. This data type is used for storing integer numbers — numbers that do not have a decimal component. For example, 0, 3, 42, and 4817 are all integers. The following section, “Work with Integers,” provides examples of working with the int data type in Python. Technically, the bool data type for storing Boolean values is a subtype of int.
• float. This data type is used for storing floating-point numbers, those that have a decimal component. For example, 9876.54321 is a floating-point number. The section “Work with Floating-Point Values,” later in this chapter, gives you examples of working with the float data type in Python.
• complex. This data type is used for storing complex numbers — numbers that consist of a real component and an imaginary component. Complex numbers have mostly specialized uses beyond the scope of this book.

Understanding the Sequence Data Types

In Python, a sequence is a set of data that is ordered — in other words, it has a specific order. Some sequence data types are immutable, or unchangeable, whereas others are mutable, or changeable.

The following list explains the main data types in the sequence category:

• list. This data type contains a sequence of similar items — for example, a list of integers might contain 1, 2, and 3, or a list of strings might contain dog, cat, and snake. Lists are mutable, so you can change their contents, their order, or both. See the section “Start Working with Lists,” later in this chapter, for more about this data type.
• tuple. This data type is used to store an ordered sequence of values. The values do not need to be unique, so a tuple can contain multiple instances of the same value. A tuple is immutable, so you cannot change its contents or its order once you have created it. See the section “Work with Tuples,” later in this chapter, for more about this data type.
• range. This data type is used to contain an immutable sequence of integer values — for example, from 1 to 10. Ranges are often used to control the number of iterations in for loops.
• str. This data type is used for storing strings of text. Python considers a string to be an immutable — unchangeable — sequence of characters. The section “Start Working with Strings,” later in this chapter, gets you started with the str data type, while Chapter 9, “Working with Text,” shows you the most useful moves with strings.

Understanding the Set Data Type

In Python, the set data type enables you to store multiple values in a single variable. The set data type has the following characteristics:

• It contains elements. The elements, also called members, are the discrete objects that make up the set.
• Each element is unique. A set cannot have duplicate elements. By contrast, a list or a tuple can have duplicate elements.
• It is unordered. The elements in a set have no specific order. This means you cannot refer to an element in a set by its index or position.
• It is immutable. Once you have created a set, you cannot change its existing items, but you can add further items to the set if you need to.

The section “Work with Sets,” later in this chapter, gives you an example of creating and manipulating a set.

Understanding the Mapping Data Type

Python’s mapping category contains a single data type, dict, which is used for dictionaries. A dictionary consists of key/value pairs, with the key in each pair giving you access to set, retrieve, or modify the associated collection of information in the value.

A dictionary is unordered; you access the data by supplying the appropriate key rather than an index value. A dictionary is mutable, so you can change its contents after creating it.

The section “Start Working with Dictionaries,” later in this chapter, introduces working with dictionaries. Chapter 11, “Working with Lists and Dictionaries,” goes into dictionaries in depth.

Understanding Python’s Classes

In Python, a class is a kind of template you use for creating a new object of a particular type. You can create a class object to organize the functions and other code in a particular project.

That sounds nebulous, but if you work with office productivity software, you are likely used to a similar paradigm. For example, if you need to create many memos of the same type in Microsoft Word, you may create a custom memo template containing the layout and formatting for the memo, and perhaps some VBA code for automation. That memo template is analogous to a Python class.

Chapter 12, “Working with Classes,” explains how classes work, tells you what classes are useful for, and shows you how to create a class and put it to use.

Understanding the Instance Data Type

In Python, an instance is an individual object created from a particular class. For example, say you create a class that contains the functions needed to run a particular data-aggregation and assessment task. When you want to work on that data, you create an instance of the class — or, to use the formal term, you instantiate the class.

Continuing the previous example, when you need to produce a memo, you create a new document based on your memo template rather than using the memo template itself. The document is analogous to an instance of the template class.

Chapter 12, “Working with Classes,” covers how to create and use instances of your custom classes.

Understanding the Exception Data Type

In Python, an exception is an object representing an error that occurred during code. Chapter 10, “Handling Errors,” shows you how to work with Python’s built-in exceptions to handle errors when they occur. This chapter also explains how to create custom exceptions.

Understanding Implicit Conversion and Explicit Conversion

Python performs two types of data conversion: implicit conversion and explicit conversion.

Implicit conversion occurs when Python automatically converts an existing value to a different data type to avoid losing data. For example, if you create a variable named intTest and assign the integer value 1, Python gives the value the int data type. But if you add a float, such as 3.19, to intTest, Python changes the value’s data type to float so as not to lose the data that could not be stored in the int data type.

Explicit conversion occurs when you use a data-conversion function to convert data to a different type, as explained in this section. Explicit data conversion is also called type casting or simply casting. For example, you might cast an integer to a float.

Understanding What Kinds of Data You Can Convert

Python’s data-conversion functions are effective and easy to use, but they work only with suitable data. For example, if the variable strQuantity contains the string data "20" — including the double quotes, which delimit the string — you can use int(strQuantity) to convert the string "20" to the integer 20. But if strQuantity contains "Twenty", using int(strQuantity) returns an error.

Meet Python’s Functions for Converting Data

Table 3-1 summarizes the functions that Python provides for converting data from one data type to another. You will notice that each function shares the name of the data type to which it converts data. For example, the bool() function converts data to the bool data type, the int() function converts data to the int data type, and the tuple() function converts data to the tuple data type.

Examples of Using Python’s Data-Conversion Functions

Here are brief examples of using Python’s data-conversion functions:

• chr(76) returns L, the ASCII character represented by 76; ord("L") returns 76, the ASCII character number.
• bool(1>2) returns False, because 1 is not greater than 2.
• complex(4,7) returns the complex number 4 + 7j.
• dict_Subjects = {1: "History", 2: "Geography", 3: "Math"} returns a dictionary with three subjects identified by integer keys.
• float(1  +  1.111) returns a float containing 2.111, rounded.
• hex(64000) returns 0xfa00, the hexadecimal value for 64000.
• int(47.2536) returns the integer 47.
• list(("death","sickness","taxes")) returns a list containing those three cheerless nouns.
• oct(64) returns 0o100, the octal value for 64.
• set(myTuple) returns a set containing the unique values from the myTuple collection.
• str(45 + 99) returns a string containing 144.
• tuple(("shoes", "boots", "waders", "sandals")) returns a tuple containing ill-assorted footwear.