Python Data Types and Structures

 

Programming languages store and process data of various types as variables, and are defined by their type. Datatypes dictate how the data is represented and what operations can be performed with the data. One method by which a datatype can be assigned to a variable is through casting, which is achieved using the appropriate constructor.

 

If a variable's data type is unknown, Python offers the following functionality to return the variable's type:

 

Python's built-in data types are broken out into five categories: Numeric, Boolean, Sequence, Mapping, and Sets. Generally, data types define the kind of data stored in a variable, and data structures define how the data is organized and stored. In other words, data structures are collections of data types.

 

These types are detailed below, along with some examples and useful Python methods that facilitate processing data of various types and structures. Practice implementing various data types through these exercises.

 

 

 

None

·       None: null value or null object, represents the absence of an object

o   NOT the same as False, 0, or an empty variable

o   Used as a default value when a true value does not exist or is yet to be defined

o   None is a data type of the class NoneType object

§  Example: None

Numeric

·       Integer: Numeric, Whole

• Represents a whole number on (-∞, ∞)
• Constructor: int(<value>)
• Example: 100

 

 

·       Float: Numeric, Decimal

• Represents a floating-point number on (-∞, ∞)
• Constructor: float(<value>)
• Example: 100.0
• Example: 100.3

• Complex: Numeric, Complex
• Represents a complex number in the form x+yj, where 'j' represents the imaginary number
• Constructor: complex(<value>)
• Example: 100j

Boolean

·       Boolean: Binary, False/True, 0/1

o   True or False values, also represented as 1 or 0, respectively. This is particularly useful for comparison operations, where populated variables or data structures are True, and otherwise False.

§  Constructor: bool(<value>)

§  Example: True

§  Example: 1

§  Example: False

§  Example: 0

 

o   True is the same as 1, and False is the same as 0

o   bool(“”) yields False

o   bool(“<char>”) yields True

Sequence

·       String: Text, sequence of characters

• A string literal is a sequence of characters, numbers, or symbols hardcoded directly into your code, typically enclosed in single or double quotation marks.
• Individual character, sentences, etc, and individual characters can be accessed by their numeric index corresponding to the character's position in the string.
• Constructor: str(<value>)
• Example: "Hello World!"

 

• NOTE: numeric characters cast as a string type cannot perform mathematical operations.
• Example: "Did you know that 2+2=4?"
• “2”  2
• “2”: Text
• 2: Numeric

 

 

String Methods

 

 

Strings can also contain escape characters, which generally represent illegal characters in a string. For example, double quotes are considered illegal characters because Python already recognizes single and double quotes as string syntax. Alternatively, a user can insert double quotes in a string by preceding that piece of the text with a backslash:

 

Escape characters can also define how a string is spaced and distributed. These escape characters are placed directly in the text where the user wants a particular spacing or distribution to occur. Some escape characters include:

String Escape Characters

 

 

Dynamic Typing formats strings that contain variables that are not explicitly defined. These variables may be defined programmatically or as user inputs, and can be represented in a string with curly braces, {}. Examples of how this is achieved are shown below:

 

**A user is prompted to input the <current_month> and <current_day> as string values:

 

% is the placeholder for the variable in the string and 's' indicates that the variable is a string type. In this instance, we have multiple string inputs so the sequence in which the variables are defined determines the sequence in which they occur in the string

 

 

Empty string variables are populated sequentially by the format variable's index

 

 

String variables containing integers are defined by the pertaining format variable's index

OR

 

 

String variables containing variable names are defined by format variable's assigned value

 

The 'f' is used to format the string literal directly (introduced in Python 3)

If a float type is being inserted into a string, it can be follow the methods above or be further formatted using the methods below:

 

** A user is prompted to input a price:

 

The price is inserted into a string and formatted to show 2 decimal places

The price is inserted into a string literal and formatted to show 3 decimal places

 

Data Structures

·       Data structures are containers within which data can be stored. Data within data structures can be standalone data of the types defined above, or other data structures through a process known as nesting

 

·       Terminology

o   Ordered: Container retains the order of the values

o   Mutable: Container values can be changed

o   Heterogeneous: Container multiple more than one data type

o   Duplicates: Container allows repeated values

 

·       The four data structures to know are Lists, Tuples, Dictionaries, and Sets.

 

·       List: An ordered sequence structure for storing a collection of items in a single variable

 

o   It is one of the most versatile and frequently used data types in the language

o   Syntax: [<val_0>, <val_1>]

o   Properties:

§  Ordered: YES

§  Mutable: YES

§  Heterogeneous: YES

§  Duplicates: YES

§  Indexable: YES (integer)

List Methods

 

 

·       Tuple: An ordered sequence structure for storing a collection of items in a single variable

 

o   Syntax: (<val_0>, <val_1>)

o   Properties:

§  Ordered: YES

§  Mutable: NO

§  Heterogeneous: YES

§  Duplicates: YES

§  Indexable: YES (integer)

 

Tuple Methods

 

Values can be appended to tuples. However, given their immutable nature, there is a specific process by which this is achieved. Tuples can only be concatenated with other tuples, so the following process satisfies this requirement:

 

1.       Identify the primary tuple

 

 

2.       Identify the other tuple within which values to append are contained

 

 

3.       Perform an addition of the primary tuple and other tuple, and assign to a variable

 

 

4.       The new tuple contains the primary tuple values and the other tuple values

 

This is the only way to append values to an existing tuple. If an individual value is being appended to an existing tuple, it must first be cast as a tuple, thereby satisfying the tuples requirement:

 

 

OR

 

 

 

Note that the parentheses when defining a tuple are optional, as Python recognizes when a tuple is being created:

 

 

is the same as

 

 

is the same as

 

 

 

The parentheses indicate how the variables are stored in the collection. When the tuple is a part of another collection, the parentheses are necessary to define the structure. For example:

 

 

is NOT the same as

 

 

is NOT the same as

 

 

 

In the examples above, variable 'y' is a list of values, whereas variable 'z' is a list comprised of a tuple. The variables 'a, b' are assigned integers 5 and 11, respectively, through what is known as destructuring or decomposing.

Mapping

·        Dictionary: Also known as a hashmap, a mapping data structure that stores data in key-value pairs

o   Efficiently retrieves stored data by mapping a key (think of this as an address) to its corresponding value

§  This is significantly more efficient than sequentially iterating through a data structure index by index

 

o   Syntax: {<key>: <value>}

o   Properties:

§  Ordered: Yes 3.7+ (keys will follow the order listed in the source code)

§  Mutable: YES (keys are immutable, values are mutable)

§  Heterogeneous: YES (keys can be different data types)

§  Duplicates: NO (keys must be unique, values can be repeated)

§  Indexable: YES (keys)

 

Dictionary Methods

 

·        Keys and Values don’t have defined data types, so the developer gets to define them in the code design

o   Keys can be any data type (str, int, float, bool, None)

§  Keys are unique

§  Keys are immutable

o   Values can be any data type (str, int, float, bool, None) OR data structure (list, tuple, set, dict)

§  There is no limit to how many data structures you nest, but indexing can become complex when you need to access the dictionary values

 

Set

·       Set: Unordered collections of unique elements, and the structure is designed to test membership and perform mathematical operations, like a Venn Diagram

 

o   Syntax: {<val_0>, <val_1>}

o   Properties:

§  Ordered: NO

§  Mutable: YES

§  Heterogeneous: YES

§  Duplicates: NO

§  Indexable: NO (unordered structure cannot be indexed)

 

Set Methods

 

 

Set Value Membership Methods

 

 

NOTE: 1 and True, and 0 and False are considered the same value in sets, so the Boolean value and equivalent numeric value cannot exist in the same set

 

Operators

 

Assignment Operator

 

 

Conditional Statements

Code will step through the comparison block from top to bottom and exit the block once a condition is met, even if the conditions later in the block have not been checked yet.  The order in which a comparison block is built matters!

 

If <conditional_statement>:

              <action to execute>

elif <conditional_statement>:

              <action to execute>

elif <conditional_statement>:

              <action to execute>

else:

              <action to execute for all other conditions not captured above>

 

 

 

Comparison Operators

 

 

Identity Operator

 

 

Logical Operators

 

 

Math Operators

 

 

Helpful Resources

• GeeksforGeeks
• W3Schools
• W3Schools Python Exercises 1
• W3Schools Python Exercises 2