Scribd
Upload
2 views

python-practicals (5)

The document outlines three practical programming exercises in Python: Local Variable Program, Global Variable Program, and Static Variable Program. Each exercise demonstrates different concepts such as local and global variable scope, variable lifetime, and the use of static variables in classes. The document includes code examples and output results to illustrate the functionality of these programming concepts.

Uploaded by

mohitnayak.229548
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
2 views

python-practicals (5)

The document outlines three practical programming exercises in Python: Local Variable Program, Global Variable Program, and Static Variable Program. Each exercise demonstrates different concepts such as local and global variable scope, variable lifetime, and the use of static variables in classes. The document includes code examples and output results to illustrate the functionality of these programming concepts.

Uploaded by

mohitnayak.229548
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 5

Practical 14: Local Variable Program

Practical Name: Local Variable Program Objective: To demonstrate local


variable scope and lifetime in Python functions.
def demonstrate_local_variables():
def outer_function():
# Local variable in outer function
outer_var = "I'm in outer function"

def inner_function():
# Local variable in inner function
inner_var = "I'm in inner function"
print("Inside inner_function:")
print(f"Inner variable: {inner_var}")
print(f"Can access outer variable: {outer_var}")

print("Inside outer_function:")
print(f"Outer variable: {outer_var}")
inner_function()
try:
print(inner_var) # This will raise an error
except NameError as e:
print(f"Cannot access inner_var from outer function: {e}")

# Demonstrate variable lifetime


def counter_function():
count = 0 # Local variable
count += 1
return count

print("Demonstrating local variables:")


outer_function()

print("\nDemonstrating variable lifetime:")


print(f"First call: {counter_function()}")
print(f"Second call: {counter_function()}")
print(f"Third call: {counter_function()}")

demonstrate_local_variables()
Output:
Demonstrating local variables:
Inside outer_function:
Outer variable: I'm in outer function
Inside inner_function:

1
Inner variable: I'm in inner function
Can access outer variable: I'm in outer function
Cannot access inner_var from outer function: name 'inner_var' is not defined

Demonstrating variable lifetime:


First call: 1
Second call: 1
Third call: 1

Practical 15: Global Variable Program


Practical Name: Global Variable Program Objective: To demonstrate global
variable usage, modification, and best practices in Python.
def demonstrate_global_variables():
# Global variable declaration
global_counter = 0

def modify_global_correct():
global global_counter
global_counter += 1
print(f"Global counter inside function: {global_counter}")

def modify_global_incorrect():
try:
global_counter += 1 # This will raise an error
except UnboundLocalError as e:
print(f"Error without global keyword: {e}")

class CounterClass:
class_counter = 0 # Class variable (similar to global)

def increment(self):
CounterClass.class_counter += 1
return CounterClass.class_counter

print("Initial global counter:", global_counter)


modify_global_correct()
print("Global counter after modification:", global_counter)

print("\nTrying to modify global without 'global' keyword:")


modify_global_incorrect()

print("\nDemonstrating class variables:")


counter1 = CounterClass()
counter2 = CounterClass()

2
print(f"Counter1 increment: {counter1.increment()}")
print(f"Counter2 increment: {counter2.increment()}")
print(f"Class counter value: {CounterClass.class_counter}")

demonstrate_global_variables()
Output:
Initial global counter: 0
Global counter inside function: 1
Global counter after modification: 1

Trying to modify global without 'global' keyword:


Error without global keyword: local variable 'global_counter' referenced before assignment

Demonstrating class variables:


Counter1 increment: 1
Counter2 increment: 2
Class counter value: 2

Practical 16: Static Variable Program


Practical Name: Static Variable Program Objective: To demonstrate static
variables and class-level attributes in Python classes.
def demonstrate_static_variables():
class Employee:
# Static variables
company_name = "TechCorp"
employee_count = 0

def __init__(self, name):


self.name = name # Instance variable
Employee.employee_count += 1 # Modifying static variable

@staticmethod
def get_company_info():
return f"Company: {Employee.company_name}, Employees: {Employee.employee_count}"

@classmethod
def change_company_name(cls, new_name):
cls.company_name = new_name

# Demonstrate static variable usage


print("Initial company info:")
print(Employee.get_company_info())

3
# Create employees
emp1 = Employee("Alice")
emp2 = Employee("Bob")
print("\nAfter creating employees:")
print(Employee.get_company_info())

# Change company name


Employee.change_company_name("NewTech")
print("\nAfter changing company name:")
print(Employee.get_company_info())

# Demonstrate static variable sharing


print("\nAccessing through instances:")
print(f"Employee 1 company: {emp1.company_name}")
print(f"Employee 2 company: {emp2.company_name}")

# Demonstrate instance vs static variables


emp1.department = "IT" # Instance variable
print("\nInstance variables:")
print(f"Employee 1 department: {emp1.department}")
try:
print(f"Employee 2 department: {emp2.department}")
except AttributeError as e:
print(f"Employee 2 department: Not found - {e}")

demonstrate_static_variables()
Output:
Initial company info:
Company: TechCorp, Employees: 0

After creating employees:


Company: TechCorp, Employees: 2

After changing company name:


Company: NewTech, Employees: 2

Accessing through instances:


Employee 1 company: NewTech
Employee 2 company: NewTech

Instance variables:
Employee 1 department: IT
Employee 2 department: Not found - 'Employee' object has no attribute 'department'
Would you like me to continue with the next set of practicals? We can cover

4
method overloading, classes, modules, and file operations next.

You might also like