Python Data Types

• Python is a high-level, interpreted, general-purpose programming language.
• Python emphasizes code readability with its notable use of significant indentation.

Data Types

• Data types represent the classification of data items.
• Data types represent the kind of value that tells what operations can be performed on a particular data.
• In Python, data types are classes and variables are instances (objects) of these classes.

Standard Data Types

• Python has several built-in data types, including:
  • Numeric
  • Text Type
  • Boolean
  • Sequence Types
  • Mapping Type (Dictionary)
  • Set Types

Numeric Types

• Represents data that has a numeric value.
• Numeric values can be integers, floating numbers, or complex numbers.
  • int - Integer: Whole numbers, either positive or negative, without any decimal points. Unlimited length.
  • float - Floating-point number: Any real number with a decimal point representation. Specify precision up to 15 decimal places.
  • complex - Complex number: Numbers with a real and an imaginary component, represented as a + bj, where 'a' is the real part, and 'b' is the imaginary part.

Text Type

• Represents textual data using strings.
  • str - String: A sequence of characters enclosed in single quotes, double quotes, or triple quotes. Strings are immutable.
    • Triple quotes are used for multiline strings.
    • Python strings can be indexed and sliced.

Boolean Type

• Represents truth values.
  • bool - Boolean: Has two possible values: True or False.
    • Boolean values are often the result of logical operations.
    • True and False are keywords in Python and must be capitalized.
    • Booleans are a subtype of integers; True is equivalent to 1 and False is equivalent to 0.

Sequence Types

• Represents ordered collections of items.
  • list - List: An ordered, mutable (changeable) collection of items, which can be of different data types. Defined with square brackets [].
    • Lists allow duplicate members.
    • Lists can be indexed, sliced, and manipulated using various built-in methods.
  • tuple - Tuple: An ordered, immutable (unchangeable) collection of items, which can be of different data types. Defined with parentheses ().
    • Tuples allow duplicate members.
    • Tuples are faster than lists when iterating.
  • range - Range: Represents an immutable sequence of numbers. Commonly used for looping a specific number of times.
    • Defined using the range() function, which can take one, two, or three arguments: start, stop, and step.
    • The sequence starts at the 'start' value (default 0), increments by 'step' (default 1), and stops before the 'stop' value.

Mapping Type

• Represents key-value pairs.
  • dict - Dictionary: An unordered, mutable collection of key-value pairs.
    • Each key must be unique and immutable (e.g., string, number, or tuple).
    • Values can be of any data type and can be duplicated.
    • Dictionaries are defined using curly braces {}.

Set Types

• Represents unordered collections of unique items.
  • set - Set: An unordered collection of unique items. Defined with curly braces {}.
    • Sets do not allow duplicate members.
    • Sets support mathematical operations like union, intersection, difference, and symmetric difference.
  • frozenset - Frozenset: An immutable version of a set.
    • After creation, elements cannot be added or removed.

Determining Data Type

• The type() function returns the data type of an object.
• Use isinstance() to check if an object is an instance of a particular class (data type).

Type Conversion

• Converting between data types is called type conversion or type casting.
• Implicit Type Conversion: Python automatically converts one data type to another.
  • Example: When an integer is added to a floating-point number, the integer is implicitly converted to a float before the addition.
• Explicit Type Conversion: Use built-in functions to convert between data types such as:
  • int(): Converts a value to an integer.
  • float(): Converts a value to a floating-point number.
  • str(): Converts a value to a string.
  • bool(): Converts a value to a Boolean.
  • list(), tuple(), set(): Converts a value to a list, tuple, or set, respectively.

Mutable vs Immutable Data Types

• Mutable: Mutable data types can be changed after creation.
  • Lists, dictionaries, and sets are mutable.
• Immutable: Immutable data types cannot be changed after creation.
  • Numbers (integers, floats, complex numbers), strings, tuples, and frozensets are immutable.
  • When an immutable object appears to be modified, a new object is created.

Operators and Data Types

• Arithmetic Operators: +, -, *, /, // (floor division), % (modulus), ** (exponentiation). Work numeric types.
• Comparison Operators: ==, !=, >, <, >=, <=. Return Boolean values.
• Logical Operators: and, or, not. Work with Boolean values.
• Assignment Operators: =, +=, -=, *=, /=, etc.
• Membership Operators: in, not in. Used to test if a sequence is present in an object.
• Identity Operators: is, is not. Used to compare the objects, not if they are equal, but if they are actually the same object in memory.