Python: Data Types and Structures

 

Object-Oriented Programming (OOP)

·       OOP is a coding paradigm that organizes code around objects

o   Objects: bundles of data (attributes) and behaviors (methods)

 

Everything in Python is an object!

 

Memory

·       CPython uses its own allocator (pymalloc) for handling large volumes of small, short-lived objects efficiently

o   CPython is the  original and most widely used implementation of the Python language

§  Python is the language specification, including rules for syntax and semantics

§  CPython is the software that actually runs Python, written primarily in C

·       Memory is requested from the OS in large chunks (arenas), which are divided into ‘pools’, then into fixed-sized ‘blocks’

o   Avoids the overhead of asking the OS for memory on every object creation

·       Python caches certain common objects (small int, simple string literals) to avoid redundant allocations

 

Python manages memory in two abstractions:

·       Stack Memory: Manages function execution and object heap addresses (references, pointers), but does not store actual data

o   Every function pushes a new stack frame onto the call stack

o   Stack frames hold local variable names as references, arguments, return addresses, and evaluation/bytecode position

§  Does NOT store data

o   Stacks are LIFO

o   A stack frame is destroyed when function returns

o   Recursive calls stack multiple frames of the same function, but too many nested calls exceeds the stack limit (RecursionErrorr)

·       Heap Memory: Stores all objects and data structures (lists, strings, dictionaries, etc.)

o   Assignment (b=a) copies a reference, not the value, which is why mutable objects can be changed through multiple names pointing to the same heap object

o   Heap objects persist as long as something references them, and are managed automatically by Python’s memory system

o   Every object has a reference count tracking how many things point to it

o   Cyclic Garbage Collector (gc module) periodically scans for and cleans up unreachable cycles

§  Objects that survive collection get promoteed to older generations that are scanned less often

·       Long-lived objects are less likely to become garbage

 

Virtual environments dedicate a filesystem that isolates the interpreter binary and site packages that a project directory uses

·       Python interpreter binary is not duplicated, but it’s usually a symlink (or a small copy on Windows) pointing back to the system interpreter

·       Virtual environments give each project its own copy of the packaged ecosystem

·       Every Python process has identical stack/heap  mechanics once running

·       Activating a virtual environment updates sys,path to point to the virtual environment directory instead of the global directory

·       All packages installed when the virtual environment is active are installed in that directory instead of the global directory, which means that the environment must be active for code to access them

·       Virtual environments are NOT portable, but requirements files can help replicate its contents

 

Since the Python interpreter manages memory, developers don’t need to manually allocate or free memory

 

Data Types

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 specialized storage formats for organizing, managing, and storing data in computer memory so it can be accessed and modified efficiently

 

·       Terminology

o   Ordered: Container retains the order of the values, every object has an ‘address’ in the structure

o   Mutable: Container values can be changed

o   Heterogeneous: Container supports 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>, …, <val_n>]

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>, …, <val_n>)

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_0>: <val_0>, <key_1>: <val_1>, …, <key_n>: <val_n>}

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>, …, <val_n>}

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