Python Numeric Types

• Python is a high-level, interpreted, general-purpose programming language.
• Python's design philosophy emphasizes code readability with the use of significant indentation.
• Python is dynamically typed and garbage-collected.
• It supports multiple programming paradigms, including structured (particularly procedural), object-oriented, and functional programming.
• Python is often described as a "batteries included" language due to its comprehensive standard library.
• Python consistently ranks among the most popular programming languages.
• It is used in diverse domains, including web development, data science, artificial intelligence, and scientific computing.

Basic Data Types

• Python has several built-in data types used to represent different kinds of values.
• These include numeric types, sequences, and mappings.

Numeric Types

• Numeric types represent numerical values.
• The three distinct numeric types are integers, floating-point numbers, and complex numbers.

Integers (int)

• Integers represent whole numbers, which can be positive or negative.
• There is no limit to the size of an integer in Python.
• Examples: 10, -5, 1000000

Floating-Point Numbers (float)

• Floating-point numbers represent real numbers with decimal points.
• They are represented using double precision.
• Examples: 3.14, -2.5, 0.001
• Floating-point numbers are subject to limitations in precision due to the way they are stored in computer memory.

Complex Numbers (complex)

• Complex numbers have a real and imaginary part.
• They are written in the form a + bj, where a is the real part, b is the imaginary part, and j is the imaginary unit.
• Examples: 2 + 3j, -1.5 - 0.5j

Sequences

• Sequences are ordered collections of items.
• There are three basic sequence types: lists, tuples, and strings.

Lists (list)

• Lists are mutable, ordered sequences of items.
• Lists are defined using square brackets [].
• Elements in a list can be of different data types.
• Examples: [1, 2, 3], ['apple', 'banana', 'cherry'], [1, 'hello', 3.14]
• Lists can be modified by adding, removing, or changing elements.

Tuples (tuple)

• Tuples are immutable, ordered sequences of items.
• Tuples are defined using parentheses ().
• Examples: (1, 2, 3), ('apple', 'banana', 'cherry')
• Once a tuple is created, its elements cannot be changed.
• Tuples are often used to represent fixed collections of items.

Strings (str)

• Strings are immutable sequences of characters.
• Strings are defined using single quotes ' or double quotes ".
• Examples: 'hello', "world", '123'
• Strings support various operations like concatenation, slicing, and formatting.

Mappings

• Mappings are unordered collections of key-value pairs.
• The only built-in mapping type is the dictionary.

Dictionaries (dict)

• Dictionaries are mutable, unordered collections of key-value pairs.
• Dictionaries are defined using curly braces {}.
• Keys must be unique and immutable (e.g., strings, numbers, or tuples).
• Values can be of any data type.
• Examples: {'name': 'Alice', 'age': 30}, {1: 'one', 2: 'two'}
• Dictionaries are used to store and retrieve data based on keys.

Boolean Type (bool)

• The boolean type represents truth values: True and False.
• Boolean values are often the result of comparison operations or logical operations.
• Booleans can be used in conditional statements and loops.

None Type (NoneType)

• The None type represents the absence of a value or a null value.
• It is often used to indicate that a variable has not been assigned a value.
• None is a singleton object, meaning there is only one instance of None in Python.

Type Conversion

• Python provides functions to convert values from one data type to another.
• int(): Converts a value to an integer.
• float(): Converts a value to a floating-point number.
• str(): Converts a value to a string.
• list(): Converts a value to a list.
• tuple(): Converts a value to a tuple.
• dict(): Converts a sequence of key-value pairs to a dictionary.
• bool(): Converts a value to a boolean.

Operators

• Operators are symbols that perform operations on values and variables.

Arithmetic Operators

• +: Addition
• -: Subtraction
• *: Multiplication
• /: Division
• //: Floor Division (integer division)
• %: Modulus (remainder)
• **: Exponentiation

Comparison Operators

• ==: Equal to
• !=: Not equal to
• >: Greater than
• <: Less than
• >=: Greater than or equal to
• <=: Less than or equal to

Logical Operators

• and: Logical AND
• or: Logical OR
• not: Logical NOT

Assignment Operators

• =: Assign value
• +=: Add and assign
• -=: Subtract and assign
• *=: Multiply and assign
• /=: Divide and assign
• //=: Floor divide and assign
• %=: Modulus and assign
• **=: Exponentiate and assign

Bitwise Operators

• &: Bitwise AND
• |: Bitwise OR
• ^: Bitwise XOR
• ~: Bitwise NOT
• <<: Left shift
• >>: Right shift

Mutability

• Mutable data types can be changed after they are created (e.g., lists, dictionaries).
• Immutable data types cannot be changed after they are created (e.g., tuples, strings, numbers).
• When an immutable object appears to be modified, a new object is created.
• Understanding mutability is crucial for avoiding unexpected side effects in code.

Data Type Operations

• Each data type has its own set of operations that can be performed on it.
• Lists support operations like appending, inserting, removing, and sorting elements.
• Strings support operations like concatenation, slicing, and formatting.
• Dictionaries support operations like adding, removing, and accessing key-value pairs.
• Numeric types support various mathematical operations.