2.1 Variables and Assignment

NicePython

— 4 min read

2.1 Variables and Assignment

In Python, variables are used to store data, and they provide a way to refer to values by name. Unlike some other programming languages, Python does not require explicit declaration of variable types. Instead, Python uses dynamic typing, meaning that the type of the variable is inferred from the value assigned to it at runtime. In this section, we will cover the basics of variable assignment, naming conventions, and the dynamic nature of Python variables.

2.1.1 What is a Variable?

A variable is a symbolic name that refers to a value in your program. You can think of a variable as a container that holds data, allowing you to reuse that data throughout your code.

Example:

x = 5

Here, x is a variable that holds the value 5.

2.1.2 Variable Assignment

Variable assignment in Python is straightforward and follows the format:

variable_name = value
  • The = operator is used to assign a value to a variable.
  • Python automatically determines the type of the variable based on the value on the right-hand side of the assignment.

Examples:

x = 10             # Assigns the integer value 10 to the variable x
name = "Alice"     # Assigns the string "Alice" to the variable name
pi = 3.14          # Assigns the floating-point value 3.14 to the variable pi
is_active = True   # Assigns the Boolean value True to the variable is_active

In Python, the same variable can be reassigned to different data types during the execution of the program (thanks to dynamic typing):

x = 10          # x is an integer
x = "Hello"     # Now x is a string

Python allows reassignment without needing to specify types or worry about memory constraints.

2.1.3 Multiple Assignments

Python supports multiple variable assignments in a single line of code. This can be a convenient way to assign values to multiple variables simultaneously.

2.1.3.1 Assigning Multiple Variables

You can assign values to multiple variables in one line by separating the variables and values with commas:

Example:

a, b, c = 1, 2, 3

This assigns:

  • a = 1
  • b = 2
  • c = 3

2.1.3.2 Assigning the Same Value to Multiple Variables

You can also assign the same value to multiple variables:

Example:

x = y = z = 100

This assigns the value 100 to all three variables x, y, and z.

2.1.4 Naming Conventions for Variables

Python variables have specific rules for naming, and following best practices helps make your code more readable and maintainable.

2.1.4.1 Rules for Variable Names

  1. Variable names must start with a letter (a-z, A-Z) or an underscore (_). They cannot start with a number.
    • Valid: name, _name, name1
    • Invalid: 1name (variable names cannot begin with a digit)
  2. Variable names can contain letters, numbers, and underscores, but no special characters (e.g., !, @, #, -, etc.).
    • Valid: my_variable, var123
    • Invalid: my-variable (hyphens are not allowed)
  3. Variable names are case-sensitive.
    • Example: myVar, MyVar, and myvar are treated as different variables.

2.1.4.2 Best Practices for Naming Variables

  • Use meaningful names that describe the variable’s purpose.
    • Good: age, total_cost, user_name
    • Bad: a, b, c (these are not descriptive)
  • Follow PEP 8 guidelines for naming conventions:
    • Use lowercase letters with underscores (_) to separate words in variable names (snake_case).
      • Example: first_name, total_cost
  • Avoid using Python keywords (reserved words) as variable names (e.g., if, while, for, True, etc.). These keywords have specific meanings in Python and using them as variable names will cause errors.

Example of reserved keywords:

# Incorrect usage of a keyword as a variable name
if = 10  # SyntaxError: invalid syntax

2.1.5 Dynamic Typing in Python

Python is a dynamically-typed language, which means you don't need to declare the data type of a variable explicitly. The type is inferred based on the value assigned to it.

For example:

x = 42          # x is an integer
x = "Hello"     # Now x is a string

In Python, you can change the data type of a variable by assigning it a new value. There is no need to explicitly specify types.

Checking the Type of a Variable

You can check the type of a variable using the built-in type() function:

x = 42
print(type(x))  # Output: <class 'int'>

x = "Python"
print(type(x))  # Output: <class 'str'>

This flexibility can be powerful but requires attention to avoid accidentally assigning the wrong types.

2.1.6 Variable Scope

Variables in Python have different scopes, depending on where they are declared. The two primary types of scope are:

2.1.6.1 Global Variables

A global variable is declared outside any function or class, and it can be accessed from anywhere in the code.

Example:

x = 100  # Global variable

def my_function():
    print(x)  # Accessing global variable inside a function

my_function()  # Output: 100

2.1.6.2 Local Variables

A local variable is defined inside a function or block of code and is only accessible within that function or block.

Example:

def my_function():
    y = 200  # Local variable
    print(y)

my_function()  # Output: 200
# print(y)  # This will raise an error because y is not accessible outside the function

If a variable is declared both inside and outside a function, the local variable takes precedence within the function.

2.1.7 Constants

Although Python doesn’t have built-in support for constants (values that should not change), the convention is to use uppercase names to indicate a variable should be treated as a constant.

Example:

PI = 3.14159
MAX_USERS = 1000

These are not enforced by the language but serve as a guideline for developers to treat these values as immutable.

2.1.8 Deleting Variables

Python allows you to delete variables using the del keyword. This removes the reference to the variable, and it no longer exists in the memory.

Example:

x = 10
del x
# print(x)  # This will raise an error since x no longer exists

Use del with caution, as deleting variables unexpectedly can cause runtime errors.

2.1.9 Summary

  • Variables in Python are used to store and manage data.
  • The = operator is used for assignment, and Python uses dynamic typing to automatically infer the variable type.
  • Variable names must follow certain rules, such as starting with a letter or underscore, and should adhere to best practices like using descriptive names.
  • Python supports global and local variables, each with its own scope.
  • Constants are represented using uppercase variable names by convention.
  • Variables can be deleted using the del statement.

Understanding how to create, assign, and manage variables is fundamental to writing effective Python code. In the next section, we’ll explore Python’s basic data types, including integers, floats, strings, and more.

Read more