Python Data Types Overview

Study Notes

Python's core strength lies in its dynamic typing system. Variables are not explicitly declared with types; the interpreter determines the type based on the value assigned.
Python has a rich variety of built-in data types, each serving distinct purposes.
Key data types include:
- Numeric Types:
  - int (integers): Represent whole numbers, e.g., -5, 0, 10.
  - float (floating-point numbers): Represent numbers with decimal points, e.g., 3.14, -2.5.
  - complex (complex numbers): Represent numbers with real and imaginary parts, e.g., 2 + 3j.
- Sequence Types:
  - str (strings): Sequences of characters enclosed in single quotes ('...') or double quotes ("..."). Strings are immutable.
  - list (lists): Ordered, mutable sequences of items of any type. Use square brackets [].
  - tuple (tuples): Ordered, immutable sequences of items of any type. Use parentheses (). Used for representing fixed collections of data.
- Mapping Type:
  - dict (dictionaries): Unordered collections of key-value pairs. Keys must be immutable types (e.g., strings, numbers). Use curly braces {}. Essential for storing and retrieving data using keys.
- Set Types:
  - set (sets): Unordered collections of unique items. Use curly braces {} or the set() constructor. Fundamental for membership testing and set operations. Useful for removing duplicates from a list.
  - frozenset (frozen sets): Similar to sets but immutable.
- Boolean Type:
  - bool (Booleans): Represents truth values, True or False. Used in conditional statements and logical operations.
Type Conversion (Casting): Python allows explicit conversion between data types. Functions like int(), float(), str(), list(), tuple(), set(), etc. are used for this purpose.
Type Checking: Python provides ways to check the type of a variable. The type() function returns the type of an object, useful for debugging and validation.
Mutability: Determining whether a data type can be modified.
- Mutable: Lists, Dictionaries, Sets
- Immutable: Strings, Tuples, Numbers.
Important Considerations: Understanding immutability is critical for correctly using and managing data. Modifying an immutable type creates a new object, while modifying a mutable object directly changes the original.

Examples of Data Type Usage

String:

my_string = "Hello, world!"

List:

my_list = [1, 2, 3, "a", "b"]

Accessing elements: my_list[0] returns 1
Tuple:

my_tuple = (4, 5, 6)

Dictionary:

my_dict = {"name": "Alice", "age": 30}

Accessing values: my_dict["name"] returns "Alice"
Set:

my_set = {1, 2, 2, 3} # Duplicate 2 is automatically removed

Numeric Types

x = 10  # Integer
y = 3.14  # Float
z = 2 + 3j  # Complex number

Boolean:

is_active = True

Type Checking:

print(type(my_string)) # Output: <class 'str'>

Type Conversion:

integer_value = int("123") # Converts string to integer

Description

Explore the foundational aspects of Python's dynamic typing and built-in data types. This quiz covers numeric types, sequence types, and their applications, making it essential for beginners wanting to understand Python's type system. Test your knowledge and enhance your programming skills in Python.