Python - Variables

In Python, variable unpacking is a feature that allows you to assign multiple values to multiple variables in a single line. This can be done using iterable unpacking, which involves extracting elements from an iterable (e.g., a tuple, list, or string) and assigning them to individual variables.

Here's an example program illustrating variable unpacking:

# Variable unpacking in Python
coordinates = (3, 7)

# Unpacking the tuple into two variables
x, y = coordinates

print("Original tuple:", coordinates)
print("Unpacked variables - x:", x, ", y:", y)

In this example, the coordinates tuple is unpacked into two variables x and y. The values from the tuple are assigned to these variables in the order they appear in the tuple.

In Python, reference counting is a memory management technique used to keep track of the number of references to an object. Every object in Python has a reference count, and when the count drops to zero, the memory occupied by the object is deallocated. The reference count is incremented when a new reference to the object is created and decremented when a reference goes out of scope or is explicitly deleted.

Here's an example program illustrating reference counting in Python:

# Reference counting example
variable_a = [1, 2, 3]  # Reference count of the list is 1

variable_b = variable_a  # Reference count is now 2

del variable_a  # Reference count is decremented to 1

variable_b = "Hello"  # Reference count of the list is now 0, and memory is deallocated

In this example, the list variable_a is created with a reference count of 1. When variable_b is assigned the value of variable_a, the reference count becomes 2. Deleting variable_a reduces the reference count to 1, and when variable_b is reassigned, the reference count becomes 0, leading to the deallocation of memory.

In Python, you can convert a variable from one data type to another using type conversion functions or methods. These functions include int(), float(), str(), etc.

Here's an example program demonstrating variable type conversion:

# Variable type conversion example
integer_variable = 42
float_variable = 3.14
string_variable = "123"

# Converting integer to float
float_from_integer = float(integer_variable)
print("Float from integer:", float_from_integer)

# Converting float to integer
integer_from_float = int(float_variable)
print("Integer from float:", integer_from_float)

# Converting string to integer
integer_from_string = int(string_variable)
print("Integer from string:", integer_from_string)

In this example, the variables integer_variable, float_variable, and string_variable are converted to different data types using the float() and int() functions. Type conversion allows you to change the data type of a variable as needed.

In Python, shallow copy and deep copy are two methods used to duplicate objects, such as lists or dictionaries. The difference lies in how they handle nested objects. Shallow copy creates a new object but does not create new objects for the elements within the container, while deep copy creates a completely independent copy with new objects for all nested elements.

Shallow Copy: Shallow copy creates a new object but does not create new objects for the elements within the container.

import copy

original_list = [1, [2, 3], 4]

shallow_copied_list = copy.copy(original_list)

# Modify the original list to demonstrate shallow copy behavior
original_list[1][0] = 'X'

print("Original list:", original_list)  # [1, ['X', 3], 4]
print("Shallow copied list:", shallow_copied_list)  # [1, ['X', 3], 4]

Deep Copy: Deep copy creates a completely independent copy with new objects for all nested elements.

import copy

original_list = [1, [2, 3], 4]

deep_copied_list = copy.deepcopy(original_list)

# Modify the original list to demonstrate deep copy behavior
original_list[1][0] = 'Y'

print("Original list:", original_list)  # [1, ['Y', 3], 4]
print("Deep copied list:", deep_copied_list)  # [1, [2, 3], 4]

In the shallow copy example, modifying a nested element in the original list reflects the change in the shallow copied list. In the deep copy example, modifying the original list does not affect the deep copied list, showcasing the independence achieved through deep copy.