Python programming and Variables

• 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 (procedural), object-oriented, and functional programming.
• Python is often described as a "batteries included" language due to its comprehensive standard library.
• Guido van Rossum created Python and first released it on February 20, 1991.
• Python 2.0 was released on October 16, 2000, and Python 3.0 was released on December 3, 2008.
• Python 2.7.18 was the last release of Python 2 and was released on April 20, 2020.

Variables

• A variable is a named storage location in a computer's memory.
• It is used to hold data values during program execution.
• Variables provide a way to label and access memory locations, making it easier to read, write, and manipulate data.
• In Python, you don't need to explicitly declare the data type of a variable.
• The type is inferred automatically based on the value assigned to it.
• To create a variable in Python, simply assign a value to a name using the assignment operator (=).
• Variable names should be descriptive and follow naming conventions.

Identifiers

• Identifiers are names used to identify variables, functions, classes, modules, and other objects in a program.
• An identifier must start with a letter (A-Z or a-z) or an underscore (_).
• The remaining characters in an identifier can be letters, numbers, or underscores.
• Identifiers are case-sensitive (e.g., myVar and myvar are different variables).
• Keywords cannot be used as identifiers, as they are reserved words with predefined meanings in Python.
• Use descriptive and meaningful names for identifiers to improve code readability.
• Avoid using single-character identifiers except for simple loop counters.
• Use a consistent naming style, such as camelCase or snake_case.

Introduction to Python Syntax

• Python syntax refers to the set of rules that govern how Python code is written and interpreted.
• Python uses indentation to define code blocks instead of curly braces or keywords.
• Lines of code within the same block must have the same level of indentation.
• Statements are typically written one per line
• To write multi-line statements, use parentheses, square brackets, or curly braces to enclose the code.
• Comments are used to add explanatory notes to the code and improve readability.
• Single-line comments start with a hash symbol (#).
• Multi-line comments are enclosed in triple quotes (''' or """).

Variable Types

• Numeric Types:
  • Integers (int): Whole numbers without a decimal point.
  • Floating-Point Numbers (float): Numbers with a decimal point.
  • Complex Numbers (complex): Numbers with a real and imaginary part.
• Text Type:
  • String (str): A sequence of characters enclosed in single quotes (' ') or double quotes (" ").
• Boolean Type:
  • Boolean (bool): Represents truth values, either True or False.
• Sequence Types:
  • List: An ordered collection of items that can be of different types, enclosed in square brackets [ ].
  • Tuple: An ordered, immutable collection of items, enclosed in parentheses ( ).
  • Range: A sequence of numbers.
• Mapping Type:
  • Dictionary (dict): A collection of key-value pairs, enclosed in curly braces { }.
• Set Types:
  • Set: An unordered collection of unique items, enclosed in curly braces { }.
  • Frozenset: An immutable version of a set.
• None Type:
  • None: Represents the absence of a value or a null value.

Naming Conventions

• Use descriptive and meaningful names that indicate the purpose or content of the variable.
• Follow a consistent naming style (e.g., snake_case for variables and functions, CamelCase for classes).
• Variable names should be lowercase, with words separated by underscores (snake_case).
• Avoid using single-character variable names except for loop counters.
• Class names should start with an uppercase letter (CamelCase).
• Function names should be lowercase, with words separated by underscores (snake_case).
• Constant names should be uppercase, with words separated by underscores.
• Prefix private variables and methods with a single underscore (_).
• Prefix strongly private variables and methods with a double underscore (__).
• Avoid using reserved keywords as variable or function names.

Scope of Variables

• The scope of a variable refers to the region of the code where the variable is accessible and can be used.
• Variables defined inside a function have local scope and are only accessible within that function.
• Variables defined outside of any function have global scope and are accessible throughout the entire program.
• If a variable is assigned a value inside a function, it is considered a local variable by default.
• To modify a global variable from within a function, you need to use the global keyword.
• Variables defined within a class have different scopes depending on whether they are instance variables or class variables.
• Instance variables are specific to each instance of the class, while class variables are shared among all instances of the class.
• LEGB Rule:
  • Local: Variables defined within the current function or block.
  • Enclosing: Variables defined in the enclosing function's scope.
  • Global: Variables defined at the top level of the module or program.
  • Built-in: Predefined names in the Python language (e.g., print, len).

Data Types

• Data types represent the type of value that a variable can hold.
• Python has several built-in data types, including:
  • Numeric Types:
    • int: Represents integers (whole numbers) without a decimal point.
    • float: Represents floating-point numbers (numbers with a decimal point).
    • complex: Represents complex numbers with a real and imaginary part.
  • Text Type:
    • str: Represents strings, which are sequences of characters.
  • Boolean Type:
    • bool: Represents boolean values, which can be either True or False.
  • Sequence Types:
    • list: Represents ordered collections of items that can be of different types.
    • tuple: Represents ordered, immutable collections of items.
    • range: Represents a sequence of numbers.
  • Mapping Type:
    • dict: Represents collections of key-value pairs.
  • Set Types:
    • set: Represents unordered collections of unique items.
    • frozenset: Represents immutable versions of sets.
  • None Type:
    • None: Represents the absence of a value or a null value.
• Python is dynamically typed, which means that the data type of a variable is determined at runtime based on the value assigned to it.
• You can use the type() function to determine the data type of a variable.
• Data types are important because they determine the operations that can be performed on a variable and how the variable is stored in memory.