Python Core Data Types

• Python is noted for its readability and extensive libraries in versatile, high-level programming.
• Object-oriented, imperative, and functional styles are among the multiple programming paradigms it supports.
• Python's dynamic typing and automatic memory management contribute to its ease of use and learning.
• It sees prevalent use across web development, data science, AI, and scripting contexts.

Core Data Types in Python

• Variables can hold specific value types, and data types classify these and the operations executable on them.
• Python includes built-in data types that span numeric, text, and sequence categories.

Numeric Types

• Numeric values encompassing integers, floating-point numbers, and complex numbers are represented.

Integers (int)

• Whole numbers, both positive and negative, are represented without decimal points.
• 10, -5, 0, and 1000000 serve as examples.
• Python 3 integers possess unlimited precision bound only by memory availability.
• Standard arithmetic operations such as addition, subtraction, multiplication, division, and exponentiation can be performed on integers.

Floating-Point Numbers (float)

• Real numbers are represented using decimal points.
• Examples include 3.14, -2.5, 0.0, and 1.618.
• Floating-point numbers default to double precision (64 bits), adhering to the IEEE 754 standard.
• Use floating-point numbers when exceeding integer value precision.

Complex Numbers (complex)

• Numbers comprising a real and imaginary part are represented.
• They are written as a + bj, where a denotes the real part, b the imaginary part, and j the imaginary unit (√-1).
• Examples: 2 + 3j, -1.5 - 0.5j.
• Complex nos can be expressed directly or created via the complex() function.
• Complex numbers are useful in mathematics, physics, and engineering for complex calculations.

Text Type

• Character sequences are represented.

Strings (str)

• Immutable sequences of Unicode characters.
• Defined using single quotes ('...'), double quotes ("..."), or triple quotes ('''...''' or """...""").
• Examples: 'hello', "Python", '''This is a multi-line string'''.
• Support various operations like concatenation, slicing, indexing, and formatting.
• String methods include upper(), lower(), strip(), replace(), and split().

Sequence Types

• Ordered item collections are represented.

Lists (list)

• Mutable, ordered sequences of items.
• Defined using square brackets [...].
• Can contain elements of different data types.
• Examples: [1, 2, 3], ['apple', 'banana', 'cherry'], [1, 'hello', 3.14].
• Support indexing, slicing, appending, inserting, removing, and sorting elements.
• List comprehensions provide a concise way to create lists.

Tuples (tuple)

• Immutable, ordered sequences of items.
• Defined using parentheses (...).
• Similar to lists but cannot be modified after creation.
• Examples: (1, 2, 3), ('apple', 'banana', 'cherry').
• Generally faster than lists due to their immutability.
• Used for grouping related data and preventing accidental modification.

Ranges (range)

• Immutable number sequences are represented.
• They are commonly used for looping through a specific number of times.
• Ranges are created via the range() function using start, stop, and step parameters.
• range(5) generates a sequence from 0 to 4.
• Ranges are memory-efficient as they generate numbers on demand rather than storing them.

Mapping Type

• Key-value pair collections are represented.

Dictionaries (dict)

• Mutable and unordered key-value pair collections.
• Keys should be unique and immutable (strings, numbers, or tuples).
• Values can be any data type.
• Defined using curly braces {...}.
• Examples: {'name': 'Alice', 'age': 30}, {1: 'one', 2: 'two'}.
• Accessed using keys to retrieve corresponding values.
• Support adding, removing, and modifying key-value pairs.

Set Types

• Unordered unique item collections are represented.

Sets (set)

• Mutable, unordered collections of unique elements.
• Defined using curly braces {...} or the set() constructor.
• Examples: {1, 2, 3}, {'apple', 'banana', 'cherry'}.
• Duplicate elements are automatically removed.
• Union, intersection, difference, and symmetric difference set operations are supported.
• Useful for tasks involving unique elements or mathematical set operations.

Frozen Sets (frozenset)

• Immutable versions of sets.
• Created using the frozenset() constructor.
• Since they are immutable, they can be used as keys in dictionaries or elements in other sets.

Boolean Type

• Truth values are represented.

Booleans (bool)

• Can have one of two values: True or False.
• Used in logical operations and control flow statements.
• Result from comparison operations (e.g., ==, !=, <, >).
• Often used to control the execution of code based on conditions.

None Type

• Represents the absence of a value or a null value.

None (None)

• A special constant.
• Often used to initialize variables that may or may not be assigned a value later.
• Returned by functions that do not explicitly return a value.
• Used to indicate that a variable does not currently refer to any object.

Type Conversion

• Functions are available to convert values among data types.
• int() converts a value to an integer.
• float() converts a value to a floating-point number.
• str() converts a value to a string.
• list(), tuple(), set() convert values to lists, tuples, or sets.
• Type conversion can be explicit (using conversion functions) or implicit (automatic during operations).

Data Type Operations

• Each data type supports specific operations and methods.
• Arithmetic operators for numeric types.
• String methods for text manipulation.
• Indexing and slicing for sequences.
• Key-based access for dictionaries.
• Set operations for sets.
• Understanding these operations is crucial for effective programming.