Python Variables and Data Types Exercises

Which of the following is a valid variable name in Python?

2variable

first_name

first-name

class

In Python, variable names (identifiers) must follow these rules:

Cannot start with a digit. (2variable is invalid)
Can contain letters, digits, and underscores (_). (first_name is valid)
Cannot include special characters like - (first-name is invalid)
Cannot use reserved keywords like class.

Therefore, Option 2: first_name is the correct choice.

What is the correct way to assign the value `10` to a variable `x` in Python?

x == 10

x := 10

x = 10

x <- 10

In Python, the single equals sign = is used for assignment. This sets the value of the variable on the left to the value on the right.

Why the other options are wrong:

Option 1 (x == 10) is a comparison operator, not an assignment.
Option 2 (x := 10) is the walrus operator introduced in Python 3.8, used in expressions, not standard assignment.
Option 4 (x <- 10) is not valid in Python; it is used in some other languages like R.

Thus, Option 3: x = 10 is correct.

Which of the following is a numeric data type in Python?

str

bool

int

list

Python has several numeric data types:

int → integers (e.g., 5, -10)
float → floating-point numbers (e.g., 3.14, -0.5)
complex → complex numbers (e.g., 2 + 3j)

Why the other options are wrong:

Option 1 (str) represents strings (text), not numbers.
Option 2 (bool) represents Boolean values (True or False), not numeric values.
Option 4 (list) represents sequences of items, not a single numeric type.

Therefore, Option 3: int is correct.

Which of the following statements about Python variables is correct?

Python variables do not require explicit type declaration.

Python variables must always be declared as int or str.

Python variables can only store numbers.

Python variables cannot be reassigned once defined.

Python is a dynamically typed language, which means you do not need to declare the type of a variable explicitly. The interpreter automatically determines the type based on the value assigned.

Why the other options are wrong:

Option 2: Variables can store any type; explicit type declaration is unnecessary.
Option 3: Variables can store numbers, strings, lists, booleans, and other data types.
Option 4: Variables in Python can be reassigned to new values at any time.

What will the following code output?

x = "Hello"
y = "World"
x = y
print(x)

Hello

World

x

y

Here, x = y assigns the value of y ("World") to x. After this assignment, x no longer holds "Hello"; it holds "World".

Why the other options are wrong:

Option 1 (Hello) → The original value of x is overwritten.
Option 3 (x) → Variables print their value, not the variable name.
Option 4 (y) → Only the value "World" is printed, not the variable y itself.

This demonstrates variable assignment and overwriting values in Python.

Which of the following statements about Python’s data types is correct?

All Python data types are mutable.

Python requires explicit type declarations for all variables.

int is mutable, but list is immutable.

Some Python data types, like list, are mutable, while others, like tuple, are immutable.

In Python:

Mutable types can be changed after creation, e.g., list, dict, set.
Immutable types cannot be changed after creation, e.g., int, float, str, tuple.

Why the other options are wrong:

Option 1: Not all types are mutable; tuple and str are immutable.
Option 2: Python uses dynamic typing; type declarations are not required.
Option 3: This is the opposite; int is immutable, list is mutable.

Understanding mutable vs immutable types is important for predicting behavior of objects when passed to functions or assigned to multiple variables.

What will be the output of the following code?

x = 10
x = float(x)
print(type(x))

Here, the integer 10 is converted to a float using float(x). The type() function returns the type of the object after conversion.

Step by step:

Initially, x is an int.
After x = float(x), x becomes 10.0, which is a float.
type(x) therefore returns <class 'float'>.

Why the other options are wrong:

Option 1: x is no longer an integer after conversion.
Option 2: No string conversion is applied.
Option 3: x is not a boolean; bool() was not used.

This demonstrates type conversion and how Python’s dynamic typing allows changing the type of a variable at runtime.

Which of the following statements about Python’s `None` is correct?

None is equivalent to 0.

None is equivalent to an empty string "".

None is a boolean value.

None represents the absence of a value or a null value.

In Python, None is a special constant that represents the absence of a value or a null value. It is commonly used:

To indicate a variable has no value.
As a default return value for functions that do not explicitly return anything.

Why the other options are wrong:

Option 1 (0) → None is not numeric; it is a distinct singleton object.
Option 2 ("") → An empty string is different from None.
Option 3 (bool) → While bool(None) evaluates to False, None is not a boolean type itself.

Understanding None is important for handling missing or optional data and controlling program logic.

Which of the following demonstrates Python’s dynamic typing?

A variable’s type must be declared before use.

A variable can be reassigned to a value of a different type.

Python variables cannot store strings.

Variables cannot be reassigned once created.

Python is dynamically typed, meaning the type of a variable is determined at runtime and can change.

Example:

x = 10       # x is an int
x = "Hello"  # x is now a str

Why the other options are wrong:

Option 1: Python does not require type declaration.
Option 3: Variables can store strings and other types.
Option 4: Variables can be reassigned freely.

This flexibility makes Python code concise and easy to work with, but developers must be careful to avoid type-related errors.

Which of the following statements about multiple assignment in Python is correct?

Python does not support multiple assignment.

Multiple assignment can only assign the same value to all variables.

Multiple assignment requires all variables to be of the same type.

Python allows multiple assignment, assigning values to multiple variables in a single statement.

Python supports multiple assignment, which allows assigning values to multiple variables in a single line.

Example:

a, b, c = 1, 2, 3

Here, a is 1, b is 2, and c is 3.

Why the other options are wrong:

Option 1: Python fully supports multiple assignment.
Option 2: Multiple assignment can assign different values to each variable, not just the same value.
Option 3: Variables do not need to be of the same type; Python is dynamically typed.

Multiple assignment is useful for swapping variables or unpacking sequences efficiently:

x, y = y, x

What will be the output of the following code?

a = [1, 2, 3]
b = a
print(a is b)

False

None

True

Error

The is operator in Python checks object identity, i.e., whether two variables point to the same object in memory.

Here:

a is a list [1, 2, 3].
b = a assigns the same object reference to b.
a is b returns True because both variables reference the exact same list object.

Why the other options are wrong:

Option 1 (False) → Would be true if b were a copy of a, not the same object.
Option 2 (None) → is does not return None.
Option 4 (Error) → No error occurs; this is valid Python syntax.

This question highlights the difference between identity (is) and equality (==), which is crucial when working with mutable objects.

Which of the following statements about numeric types in Python is correct?

Python only supports integers and floats, not complex numbers.

Python automatically converts all floats to integers during arithmetic operations.

Python supports integers, floats, and complex numbers, and can perform arithmetic with mixed numeric types.

Python numeric types cannot be used in expressions with other types.

Python supports three main numeric types:

int → integers (e.g., 5, -10)
float → floating-point numbers (e.g., 3.14)
complex → complex numbers (e.g., 2 + 3j)

Python can perform arithmetic with mixed types:

x = 5       # int
y = 2.5     # float
z = x + y   # result is float

Why the other options are wrong:

Option 1: Python supports complex numbers.
Option 2: Floats are not automatically converted to integers; the result depends on the operation.
Option 4: Numeric types can be used in expressions with other numeric types.

Understanding numeric types and mixed-type arithmetic is important for accurate calculations and avoiding type errors.

What will be the output of the following code?

x = True
y = False
print(x and y or not y)

True

False

None

Error

This expression demonstrates Boolean operations and operator precedence:

and has higher precedence than or.
Step by step:

x and y → True and False → False
not y → not False → True
False or True → True

Why the other options are wrong:

Option 2 (False) → Incorrect because not y evaluates to True.
Option 3 (None) → Boolean expressions never return None.
Option 4 (Error) → This is valid syntax; no error occurs.

This helps learners understand operator precedence and logical operations in Python.

Which of the following statements about variable scope in Python is correct?

All variables in Python are global by default.

Local variables can be accessed outside the function they are defined in.

Variables defined inside a function are local by default, unless declared global.

Python does not support global variables.

In Python:

Local variables are variables defined inside a function; they cannot be accessed outside the function.
Global variables are defined outside functions and can be accessed anywhere in the module.
To modify a global variable inside a function, it must be declared with the global keyword.

Example:

x = 10  # global

def func():
    y = 5  # local
    global x
    x = 20

func()
print(x)  # prints 20

Why the other options are wrong:

Option 1: Variables are local inside functions unless declared global.
Option 2: Local variables cannot be accessed outside the function.
Option 4: Python does support global variables.

Which of the following statements about Python’s `id()` function is correct?

id() returns the value of a variable.

id() changes the memory location of an object.

id() returns the unique identifier (memory address) of an object.

id() can only be used with numeric types.

In Python, the id() function returns the unique identifier of an object, which usually corresponds to its memory address. This is useful for:

Checking if two variables point to the same object (is operator).
Understanding mutable vs immutable behavior.

Example:

a = [1, 2]
b = a
print(id(a) == id(b))  # True, same object

Why the other options are wrong:

Option 1: id() returns the identifier, not the value.
Option 2: id() does not modify the object or its memory.
Option 4: id() works with any Python object, not just numeric types.

What will be the output of the following code?

a = b = []
a.append(1)
print(b)

[]

[1]

[[], 1]

Error

Here, a = b = [] assigns the same list object to both a and b.

When a.append(1) is called, it modifies the list object in place.
Since b references the same list, printing b shows [1].

Why the other options are wrong:

Option 1: The list is not empty; it was modified via a.append().
Option 3: No nested lists are created; both variables reference the same object.
Option 4: No error occurs; this is valid syntax.

This demonstrates a common pitfall with multiple assignment and mutable objects in Python.

Which of the following demonstrates type coercion in Python?

Adding two integers: 5 + 3

Subtracting two floats: 5.5 - 2.5

Multiplying an integer by another integer: 2 * 3

Adding an integer and a float: 5 + 2.5

Python automatically coerces numeric types in operations to avoid type errors.

In 5 + 2.5, the integer 5 is coerced to a float (5.0) before the addition.
The result is 7.5, a float.

Why the other options are wrong:

Option 1 (5 + 3) → Both operands are integers; no coercion occurs.
Option 2 (5.5 - 2.5) → Both operands are floats; no coercion occurs.
Option 3 (2 * 3) → Both operands are integers; no coercion occurs.

This is important for understanding mixed-type arithmetic and predicting output types in Python expressions.

Which of the following statements about mutable and immutable objects is correct?

Immutable objects like tuple can have their elements changed after creation.

Mutable objects like list cannot be modified once created.

All Python objects are mutable.

Immutable objects cannot be changed, while mutable objects can be modified after creation.

In Python:

Immutable objects (e.g., int, str, tuple) cannot be changed after creation. Any operation that seems to modify them actually creates a new object.
Mutable objects (e.g., list, dict, set) can be modified in place without creating a new object.

Example:

t = (1, 2)
# t[0] = 5  # This would raise an error

l = [1, 2]
l.append(3)  # Modifies the list in place

Understanding this distinction is crucial for predicting behavior when passing objects to functions or copying objects.

Which of the following is the correct way to check if a variable `x` is an integer in Python?

type(x) == "int"

isinstance(x, int)

x.isint()

x == int

In Python, the isinstance() function is used to check if an object is an instance of a specific type.

Example:

x = 10
print(isinstance(x, int))  # True

Why the other options are wrong:

Option 1 (type(x) == "int") → type(x) returns a type object, not a string. Correct comparison would be type(x) == int.
Option 3 (x.isint()) → No such method exists for integers.
Option 4 (x == int) → This compares a value to a type, which is invalid.

Using isinstance() is preferred for type checking, especially when dealing with subclasses or multiple types.

Which of the following statements about constants in Python is correct?

Python has built-in constant types that cannot be changed.

Constants must be declared using the const keyword.

Python prevents reassignment of constants at runtime.

Python does not have true constants, but naming conventions (e.g., PI = 3.14) are used to indicate values should not change.

Python does not enforce constants like some other languages.

Developers follow the naming convention of using uppercase variable names to indicate that a value should be treated as constant.
Example:

PI = 3.14159
GRAVITY = 9.8

These can still be reassigned, but the convention signals to other developers that they should not change these values.

Why the other options are wrong:

Option 1: No built-in constant type exists in Python.
Option 2: Python does not have a const keyword.
Option 3: Python does not prevent reassignment; it relies on developer discipline.

This is important for writing maintainable and readable code, especially in large projects.

Python Variables and Data Types Exercises

Which of the following is a valid variable name in Python?

What is the correct way to assign the value 10 to a variable x in Python?

Which of the following is a numeric data type in Python?

Which of the following statements about Python variables is correct?

What will the following code output?

Which of the following statements about Python’s data types is correct?

What will be the output of the following code?

Which of the following statements about Python’s None is correct?

Which of the following demonstrates Python’s dynamic typing?

Which of the following statements about multiple assignment in Python is correct?

What will be the output of the following code?

Which of the following statements about numeric types in Python is correct?

What will be the output of the following code?

Which of the following statements about variable scope in Python is correct?

Which of the following statements about Python’s id() function is correct?

What will be the output of the following code?

Which of the following demonstrates type coercion in Python?

Which of the following statements about mutable and immutable objects is correct?

Which of the following is the correct way to check if a variable x is an integer in Python?

Which of the following statements about constants in Python is correct?

About This Exercise: Python – Variables and Data Types

What is the correct way to assign the value `10` to a variable `x` in Python?

Which of the following statements about Python’s `None` is correct?

Which of the following statements about Python’s `id()` function is correct?

Which of the following is the correct way to check if a variable `x` is an integer in Python?