Assignment -1 (SOLUTION)

PYTHON PROGRAMMING(BCC 302)

Ans-1:-Memory management :
1. Memory management in Python involves a private heap containing all Python objects and
data structures.
2. The management of this private heap is ensured internally by the Python memory
manager.
3. The Python memory manager has different components which deal with various dynamic
storage management aspects, like sharing, segmentation, preallocation or caching.
4. At the lowest level, a raw memory allocator ensures that there is enough room in the
private heap for storing all Python-related data by interacting with the memory manager
of the operating system.
5. On top of the raw memory allocator, several object-specific allocators operate on the
same heap and implement distinct memory management policies adapted to the
peculiarities of every object type.
6. For example, integer objects are managed differently within the heap than strings, tuples
or dictionaries because integers imply different storage requirements and speed/space
tradeoffs.
7. Python memory manager thus delegates some of the work to the object-specific
allocators, but ensures that the latter operate within the bounds of the private heap.
PEP 8:
1. A PEP is a design document providing information to the Python community, or
describing a new feature for Python or its processes or environment.
2. The PEP should provide a concise technical specification of the feature.
3. PEP is actually an acronym that stands for Python Enhancement Proposal.
4. PEP 8 is Python’s style guide. It is a set of rules for how to format the Python code to
maximize its readability.
5. A PEP is a design document providing information to the Python community, or
describing a new feature for Python or its processes or environment.
Ans-2:-Associativity is defined as the order according to which an expression with multiple
operators of the same precedence is evaluated. Generally all the operators have left to right
associativity.
For example, floor division and multiplication have the same precedence. Hence, if both floor
division and multiplication operators are present in an expression, the left one is evaluated first.
# Left-right associativity
print(6 * 5 // 2)

# Shows left-right associativity

print(6 * (5 // 2))
Output
15
12
In the code above initially 6*5 (=30) was evaluated first and hence 15 (30//2) was printed as the
output. Then we added parentheses around 5//2 so as parentheses have more precedence than
multiplication 5//2(=2) was evaluated first and then 12 (6*2) was printed as the output.

Non associative operators

Some of the operators like assignment operators and comparison operators do not have any
associativity order in python, hence they have separate rules for evaluating expressions with these
kinds of operators which cannot be expressed as associativity.
For example, the expression a > b >c neither means (a > b) > c nor a > (b > c). So the expression a
> b >c isbasically equivalent to a>b and b>c and is evaluated from left to right.

Ans-3:-When we declare a variable in C or alike languages, this sets aside an area of memory
for holding values allowed by the data type of the variable. The memory allocated will be
interpreted as the data type suggests. If it’s an integer variable the memory allocated will be
read as an integer and so on. When we assign or initialize it with some value, that value will
get stored at that memory location. At compile time, initial value or assigned value will be
checked. So we cannot mix types. Example: initializing a string value to an int variable is not
allowed and the program will not compile.
But Python is a dynamically typed language. It doesn’t know about the type of the variable
until the code is run. So declaration is of no use. What it does is, It stores that value at some
memory location and then binds that variable name to that memory container. And makes the
contents of the container accessible through that variable name. So the data type does not
matter. As it will get to know the type of the value at run-time.
Ans-4:-
Python’s programming cycle is dramatically shorter than that of traditional programming
cycle.
1. In Python, there are no compile or link steps.
2. Python programs simply import modules at runtime and use the objects they contain.
Because of this, Python programs run immediately after changes are made.
3. In cases where dynamic module reloading can be used, it is even possible to change and
reload parts of a running program without stopping it at all.
4. Since Python is interpreted, there is a rapid turnaround after program changes. And
because Python’s parser is embedded in Python-based systems, it is easy to modify
programs at runtime.
Ans-5:-Python does not have a specific syntax for multiline comments as some other
programming languages do. Instead, multiline comments are created by enclosing the text within
triple quotes (either single quotes ''' or double quotes ").
Unlike other programming languages; Python does not require you to declare variables explicitly
before using them. This means you can create a variable and start using it without any
declaration. Since Python is a dynamically-typed language, variables are created when you first
assign a value to them.
Ans-6:-
Python: Python is a high-level, interpreted, interactive and object-oriented scripting
language. It is a highly readable language. Unlike other programming languages, Python
provides an interactive mode similar to that of a calculator.
Interpretation of Python :
 1. An interpreter is a kind of program that executes other programs.
 2. When we write Python programs, it converts source code written by the developer into
an intermediate language which is again translated into the machine language that is
executed.
 3. The python code we write is compiled into python bytecode, which creates a file with
the extension .pyc.
 4. The bytecode compilation happened internally and was almost completely hidden from
the developer.
 5. Compilation is simply a translation step, and byte code is a lower-level, and platform-
independent, representation of source code.
 6. Each of the source statements is translated into a group of bytecode instructions. This
bytecode translation is performed to speed execution. Bytecode can be run much quicker
than the original source code
 statements.
 7. The .pyc file, created in the compilation step, is then executed by appropriate virtual
machines.
 8. The Virtual Machine iterates through bytecode instructions, one by one, to carry out
their operations.
 9. The Virtual Machine is the runtime engine of Python and it is always present as part of
the Python system, and is the component that actually runs the Python scripts.
 10. It is the last step of the Python interpreter.
The following tools are the static analysis tools that help to find bugs in python :
1.Pychecker: Pychecker is an open source tool for static analysis that detects the bugs from
source code and warns about the style and complexity of the bug.
2. Pylint:
 a.Pylint is highly configurable and it acts like special programs to control warnings and
errors, it is an extensive configuration file
 b. It is an open source tool for static code analysis and it looks for programming errors
and is used for coding standard.
 c. It also integrates with Python IDEs such as Pycharm, Spyder, Eclipse, and Jupyter.
Python decorators:
1. Decorators are very powerful and useful tool in Python since it allows programmers to
modify the behavior of function or class.
2. Decorators allow us to wrap another function in order to extend the behavior of wrapped
function, without permanently modifying it.
3. In decorators, functions are taken as the argument into another function and then called
inside the wrapper function.
4. Syntax :
@gfg_decorator
def hello_decorator():
print(“Gfg”)
5. gfg_decorator is a callable function, will add some code on the top of some another
callable function, hello_decorator function and return the wrapper function.
Ans-7:- In python, the use of a semi-colon (;) is optional, and it is not required to terminate
statements. If we add semi-colon at the end of a python statement, it will not produce any error,
and the program will execute correctly. However, it is considered unnecessary and unusual in
python coding conversions, and it may make your code harder to read and understand for other
developers. It’s worth noting that unlike other programming languages, where semicolon is used
to terminate statements, in Python, the end of the line indicates the end of a new line as the end
of a statement.
BENEFITS of PYTHON:
1. Easy to learn and use
2. Large Standard Library
3. Cross Platform compatibility
4. High-level Language
5. Large Community Support

Ans-8:-Programming cycle for Python :

 Python’s programming cycle is dramatically shorter than that of traditional programming
cycle.
 In Python, there are no compile or link steps.
 Python programs simply import modules at runtime and use the objects they
contain.Because of this, Python programs run immediately after changes are made.
 In cases where dynamic module reloading can be used, it is even possible to change and
reload parts of a running program without stopping it at all.
Since Python is interpreted, there is a rapid turnaround after program changes. And because
Python’s parser is embedded in Python-based systems, it is easy to modify programs at runtime.
Elements of Python :
Data types:
 The data stored in the memory can be of many types. For example, a person’s name is
stored as an alphabetic value and his address is stored as an alphanumeric value.
 Python has six basic data types which are as follows:
 Numeric
 String
 List
 Tuple
 Dictionary
 Boolean
 Numeric
 Numeric data can be broadly divided into integers and real numbers (i.e., fractional
numbers). Integers can be positive or negative.
 The real numbers or fractional numbers are called, floating point numbers in
programming languages. Such floating point numbers contain a decimal and a
fractional part.
 String
 Single quotes or double quotes are used to represent strings.
 A string in Python can be a series or a sequence of alphabets, numerals and special
characters.
 List:
 A list can contain the same type of items.
 Alternatively, a list can also containdifferent types of items.
 A list is an ordered and indexable sequence.
 To declare a list in Python, we need to separate the items using commas and enclose
them within square brackets ([ ]).
 Tuple:
 A tuple is also used to store sequence of items.
 Like a list, a tuple consists of items separated by commas.
 Tuples are enclosed within parentheses rather than within square brackets.
 Dictionary:
 A Python dictionary is an unordered collection of key-value pairs.
 When we have the large amount of data, the dictionary data type is used.
 Keys and values can be of any type in a dictionary.
 Items in dictionary are enclosed in the curly-braces () and separated by the comma (,).
 A colon (:) is used to separate key from value. A key inside the square bracket [ ] is
used for accessing the dictionary items.
 Boolean :
 In a programming language, mostly data is stored in the form of alphanumeric but
sometimes we need to store the data in the form of ‘Yes’ or ‘No’.
 In terms of programming language, Yes is similar to True and No is similar to False.
 This True and False data is known as Boolean data and the data types which stores
this Boolean data are known as Boolean data types.

Type conversion in Python :

  1. The process of converting one data type into another data type is known as type
conversion.
 2. There are mainly two types of type conversion methods in Python :
a. Implicit type conversion :
 When the data type conversion takes place during compilation or during the run time,
then it called an implicit data type conversion.
 Python handles the implicit data type conversion, so we do not have to explicitly convert
the data type into another data type

 In the given example, we have taken two variables of integer and float data types and
added them.
 Further, we have declared another variable named ‘sum’ and stored the result of the
addition in it.
 When we checked the data type of the sum variable, we can see that the data type of the
sum variable has been automatically converted into the float data type by the Python
compiler. This is called implicit type conversion.
b. Explicit type conversion:
 Explicit type conversion is also known as type casting.
 Explicit type conversion takes place when the programmer clearly and explicitly defines
the variables in the program.
Operator precedence:
 1. When an expression has two or more operator, we need to identify the correct
sequence to evaluate these operators. This is because result of the expression changes
depending on the precedence.
For example : Consider a mathematical expression: 10+ 5/5
When the given expression is evaluated left to right, the final answer becomes 3.
 2. However, if the expression is evaluated right to left, the final answer becomes 11. This
shows that changing the sequence in which the operators are evaluated in the given
expression also changes the solution.
 3. Precedence is the condition that specifies the importance of each operator relative to
the other.

Boolean expression: A boolean expression may have only one of two values: True or False.
For example: In the given example comparison operator (==) is used which compares two
operands and prints true if they are equal otherwise print false :
>>> 5 == 5
True #Output
>>> 5 == 6
False #Output

Ans-9:-7/3*1.2+3/2
=(7*1.2)/3 +1.5
=(8.4)/3+1.5
=2.8+1.5 = 4.3

Ans-10:-Python program to convert decimal to binary, octal and hexadecimal

dec =32
decimal =int(dec)
print(decimal, " in Binary : ", bin(decimal))
print(decimal, "in Octal : ", oct(decimal))
print(decimal, " in Hexadecimal : ", hex(decimal))

Ans-11:-Some expressions have multiple operators, to evaluate such complex expressions, there
is a rule of precedence in python which guides the order of evaluation in case of multiple
operators.
In case some operators have the same precedence level, associativity is used to determine the
order of evaluation of operators.
The correct order of precedence is given by PEMDAS which means Parenthesis (), Exponential
**, Multiplication *, Division /, Addition +, Subtraction
Associativity is defined as the order according to which an expression with multiple operators of
the same precedence is evaluated. Generally all the operators have left to right associativity.
For example, floor division and multiplication have the same precedence. Hence, if both floor
division and multiplication operators are present in an expression, the left one is evaluated first.

Ans-12:-
num =11
# If given number is greater than 1
ifnum > 1:
# Iterate from 2 to n / 2
fori inrange(2, int(num/2)+1):
# If num is divisible by any number between
# 2 and n / 2, it is not prime
if(num %i) ==0:
print(num, "is not a prime number")
break
else:
print(num, "is a prime number")
else:
print(num, "is not a prime number")

Ans-13:-The function int() will return a short or a long int depending on the argument value. In
Python 3.0, the function long() will call the function int(); before then, it will continue to force
the result to be a long int, but otherwise work the same way as int(). The built-in name long will
remain in the language to represent the long implementation type (unless it is completely
eradicated in Python 3.0), but using the int() function is still recommended, since it will
automatically return a long when needed.
Ans-14:-In Python, automatic conversion refers to the process by which the Python interpreter
automatically converts values between the "int" (integer) and "long" data types as needed during
arithmetic operations. This concept is more relevant in Python 2, as Python 3 has unified these
types into a single "int" type, eliminating the need for explicit conversions. However,
understanding how automatic conversion worked in Python 2 can provide insights into Python's
dynamic typing system.
Type conversion in Python refers to converting the value of one data type into another data type.
In Python, there are two ways to convert data types. In Implicit type conversion, Python
automatically converts one data type to another data type without any user's need.
there are two types of data type conversion :
1. Implicit
2. Explicit
Explicit data type conversion is where you force a Python compiler to convert a data type into
another. When python itself does data type conversion, it's called Implicit Data Type
Conversion.
In Python 2, there were two distinct integer types:

1. **int**: This was a fixed-size integer type with a limited range. The size was platform-
dependent, but in most cases, it was either a 32-bit or 64-bit integer. This meant that int could
represent integers within a specific range.

2. **long**: This was an arbitrary-precision integer type that could represent integers of
arbitrary size, limited only by available memory. Long integers were automatically used when an
integer exceeded the range of a regular int.

The concept of automatic conversion comes into play when you perform arithmetic operations
involving int and long values. Here's how it worked:

- If an operation involved two regular int values, the result was also a regular int, as long as the
result could be represented within the int's range.

- If an operation involved at least one long value, the result was promoted to a long integer to
accommodate the potentially larger result. This automatic promotion ensured that you didn't lose
data during the computation.

Let's look at an example:

```python
regular_int = 10
long_int = 10 ** 100 # A very large integer
result = regular_int + long_int
```

In this example, the result of adding a regular int to a long int would be a long int, as it needed to
accommodate the large value.

Automatic conversion was helpful because it allowed Python to handle integer operations
seamlessly, without the need for explicit type casting or manual checks for overflow. It ensured
that the result was represented accurately, whether it was a regular int or a long int, depending on
the magnitude of the result.

However, in Python 3, this distinction between int and long was removed, and the interpreter
automatically promotes the type to accommodate larger values as needed, making the concept of
automatic conversion less relevant in modern Python versions.
In Python, the conversion between different numeric types, such as int and float, is often handled
automatically through a process known as "type coercion" or "type conversion." The specific
rules for these conversions can vary between different numeric types. Here's how Python handles
the conversion between int and float:

1. **Implicit Conversion**: Python automatically converts integers to floats and vice versa
when necessary. This process is typically implicit, meaning you don't need to explicitly cast the
type.

2. **Integer to Float Conversion**: When you perform an arithmetic operation that involves
both int and float values, Python will automatically promote the int to a float to ensure that the
result is a float. For example:

```python
int_value = 5
float_value = 2.5
result = int_value + float_value # The result will be a float (7.5)
```

3. **Float to Integer Conversion**: If you want to explicitly convert a float to an int, you can use
the `int()` function. This function truncates the decimal part of the float, effectively rounding the
number towards zero. For example:

```python
float_value = 3.9
int_value = int(float_value) # The int_value will be 3
 ```

4. **Automatic Type Promotion**: In Python, during operations involving different numeric

types, the interpreter generally promotes the result to the type that can represent the most
information without loss. For example, when adding an int and a float, the result is promoted to a
float, as it can represent decimal values.

5. **Loss of Precision**: It's essential to be cautious when converting from float to int, as it may
result in a loss of precision. Rounding down to the nearest integer can lead to loss of the
fractional part of the float, which may not always be desired.

Python's automatic type conversion makes it flexible and user-friendly, as it simplifies the
handling of different numeric types in various mathematical and computational operations.
However, developers should be aware of potential precision issues when explicitly converting
between int and float, especially when rounding behavior is important for their application.

Ans-15:-In Python, data types are categorized into two main categories: mutable and immutable.
These categories refer to how objects of a particular data type can be modified after they are
created. Here's an explanation of the difference between mutable and immutable data types,
along with examples and the importance of immutability in certain contexts:

**Mutable Data Types**:

- Mutable data types are those whose values can be changed after they are created.
- When you modify a mutable object, you are working with the same object in memory, and
changes affect the original object.
- Common examples of mutable data types in Python include lists, dictionaries, and sets.

Example of a mutable data type (list):

```python
my_list = [1, 2, 3]
my_list.append(4) # This modifies the list in-place
print(my_list) # Output: [1, 2, 3, 4]
```

**Immutable Data Types**:

- Immutable data types are those whose values cannot be changed after they are created.
- When you attempt to modify an immutable object, you create a new object with the modified
value, leaving the original object unchanged.
- Common examples of immutable data types in Python include integers, floats, strings, and
tuples.

Example of an immutable data type (integer):

```python
my_integer = 5
my_integer += 1 # This creates a new integer with the value 6
print(my_integer) # Output: 6
```

**Importance of Immutability**:

1. **Consistency and Predictability**: Immutability ensures that once a value is assigned to a

variable, it remains the same throughout the program's execution. This predictability can make
code easier to understand and debug.

2. **Thread Safety**: In a multi-threaded environment, immutability can help avoid race

conditions. Since immutable objects cannot change, multiple threads can safely read them
without causing unexpected behavior.

3. **Hashing**: Immutable objects can be used as keys in dictionaries or elements in sets

because their hash values remain constant. Mutable objects, if used as keys, could lead to
unexpected results.

4. **Functional Programming**: Functional programming paradigms heavily rely on

immutability. Immutable data structures allow for easier reasoning about the behavior of
functions and make it possible to use techniques like referential transparency.

5. **Performance**: Immutable objects can be cached or shared across different parts of a

program, potentially improving performance by reducing memory overhead.

6.String Operations: In string manipulations, immutability is crucial because it guarantees that

the original string remains unchanged. This is especially important in text processing and
parsing.Ans

Ans 16:-Advantages of Dynamic Typing in Python**:

1. **Flexibility**: Python's dynamic typing allows you to change the type of a variable on the
fly. This flexibility is useful for quick prototyping and adapting to changing requirements
without requiring explicit type declarations.

2. **Concise Code**: With dynamic typing, you don't need to specify the type of a variable,
making Python code more concise and readable. This leads to shorter, more expressive code.

3. **Ease of Use**: Python's dynamic typing makes the language easier to learn and use for
beginners. You can focus on solving problems without worrying about complex type
declarations.

4. **Duck Typing**: Python follows the principle of "duck typing," where the type of an object
is determined by its behavior, not its explicit type. This makes Python versatile in working with
different data structures and libraries.

5. **Productivity**: Dynamic typing can boost productivity as it reduces the time and effort
required to write, modify, and maintain code.

**Disadvantages of Dynamic Typing in Python**:

1. **Runtime Errors**: Type-related errors may not become apparent until runtime, which can
make debugging more challenging, especially in larger codebases.

2. **Performance Overheads**: Dynamic typing can lead to performance overhead because type
checking and conversions occur at runtime. This can be a concern for performance-critical
applications.

3. **Limited Tool Support**: Some tools like code analysis and refactoring tools may not be as
effective in dynamic languages as they are in statically typed languages.

**Comparison with Static Typing in Other Languages**:

**Static Typing**:

1. **Advantages**:
- Early Error Detection: Static typing catches type-related errors at compile time, reducing
runtime errors.
- Enhanced Performance: Type information at compile time can lead to optimized code.
- Tooling Support: Static typing allows for more robust tooling, including code analysis and
refactoring tools.
2. **Disadvantages**:
- Verbosity: Static languages often require explicit type declarations, leading to more verbose
code.
- Slower Development: Initial development may be slower due to the need for type
declarations.

**Dynamic Typing (as in Python)**:

1. **Advantages**:
- Flexibility: Dynamic typing provides flexibility and conciseness in code.
- Ease of Use: It makes the language more beginner-friendly and productive.
- Duck Typing: Allows versatile handling of objects based on their behavior.

2. **Disadvantages**:
- Runtime Errors: Type-related issues may only surface at runtime, making debugging more
challenging.
- Performance Overheads: Type checks and conversions can lead to performance overhead in
some cases.

The choice between dynamic and static typing depends on the specific needs of a project.
Python's dynamic typing is well-suited for rapid development, scripting, and situations where
ease of use and flexibility are essential. In contrast, static typing in other languages offers early
error detection, better performance optimization, and stronger tooling support, making it suitable
for projects where reliability, performance, and maintainability are critical.

Ans 17:-. Data type coercion, also known as type conversion or type casting, is the process of
automatically or explicitly converting a value from one data type to another in Python. It is
essential to understand how Python handles operations between different data types and the rules
that govern these conversions. Here's an explanation of data type coercion in Python:

**Automatic Data Type Coercion**:

Python automatically performs data type coercion when you perform operations between
different data types, following a set of rules. The general principle is that Python will attempt to
convert the operands to a common data type before performing the operation. Here are some key
examples:

1. **Numeric Coercion**:
- When performing arithmetic operations between int and float, Python automatically promotes
the int to a float to maintain precision.
 - When performing operations between complex numbers and other numeric types, Python
promotes the other type to complex numbers to ensure consistency.

2. **String Coercion**:
- String concatenation using the `+` operator coerces non-string types into strings, creating a
new string.
- For example: `"The answer is " + str(42)` results in the string "The answer is 42".

**Explicit Data Type Conversion**:

In addition to automatic coercion, Python allows for explicit data type conversion using
functions like `int()`, `float()`, `str()`, and others. These functions enable you to convert a value
from one type to another when needed.

**Rules for Data Type Coercion**:

Here are some key rules that govern data type coercion in Python:

1. **Incompatible Types**: If two types are not compatible, attempting to coerce them may
result in a `TypeError`. For example, you cannot perform arithmetic operations between strings
and integers without explicitly converting them.

2. **Precedence**: When performing operations between different types, Python promotes the
operands to the type with higher precedence. For instance, during mixed-type arithmetic, integers
are promoted to floats to maintain precision.

3. **String and Non-String**: Combining a string and a non-string with the `+` operator
automatically coerces the non-string to a string to facilitate concatenation.

4. **Implicit Conversion**: Some implicit conversions happen automatically without the need
for explicit casting. For example, Python automatically converts an integer to a float when
involved in floating-point operations.

5. **Explicit Conversion**: You can explicitly convert values between types using type
conversion functions, such as `int()`, `float()`, `str()`, and others.

Here are a few examples:

```python
# Automatic coercion
result = 5 + 3.0 # Integer 5 is promoted to float for this operation.
# Explicit conversion
number_as_string = "42"
number_as_int = int(number_as_string)

# Incompatible types
result = "Hello, " + 42 # This raises a TypeError due to incompatible types.
```

Understanding data type coercion in Python is essential for writing code that handles mixed data
types effectively, whether through automatic conversion or explicit casting, and ensures that
operations are performed as expected.

Ans 18:-. In Python, the `is` and `==` operators are used to compare objects, but they serve
different purposes and have distinct behaviors:

1. **`is` Operator**:

- The `is` operator checks for identity, meaning it verifies if two variables or objects refer to
the exact same memory location in the computer's memory.
- If the objects being compared have the same memory address, `is` returns `True`. If they have
different memory addresses, it returns `False`.

```python
x = [1, 2, 3]
y = x # Both x and y reference the same list in memory
z = [1, 2, 3] # z is a different list with the same elements

print(x is y) # True
print(x is z) # False
```

Use the `is` operator when you want to check if two objects are the same instance in memory.
It is typically used to check object identity.

2. **`==` Operator**:

- The `==` operator checks for equality, meaning it verifies if two variables or objects have the
same content or value, regardless of whether they are stored at the same memory location.
- If the objects being compared have the same content, `==` returns `True`. If their content
differs, it returns `False`.
 ```python
x = [1, 2, 3]
y = [1, 2, 3] # Contains the same elements as x

print(x == y) # True
```

Use the `==` operator when you want to check if two objects have the same content or value. It
is typically used for value comparison.

**When to Use One Over the Other**:

- Use the `is` operator when you specifically want to check if two variables or objects refer to the
exact same instance in memory. It is useful when you want to know if two variables are aliases
for the same object.

- Use the `==` operator when you want to check if two variables or objects have the same content
or value, regardless of their memory location. This is the most common way to compare objects
for equality in Python.

Ans 19:-**Local Variables**:

1. **Scope**: Local variables are defined within a specific block or function, and their scope is
limited to that block or function. They are not accessible outside of the block or function where
they are defined.

2. **Lifetime**: Local variables have a limited lifetime and exist only as long as the block or
function in which they are defined is executing. Once the block or function exits, the local
variables are destroyed.

3. **Example**:

```python
def my_function():
x = 10 # 'x' is a local variable
print(x)

my_function()
print(x) # This will raise an error because 'x' is not defined in this scope.
 ```

**Global Variables**:

1. **Scope**: Global variables are defined outside of any function or block and can be accessed
from any part of the program, including within functions.

2. **Lifetime**: Global variables persist throughout the entire lifetime of the program. They are
created when the program starts and remain until it ends.

3. **Example**:

```python
x = 10 # 'x' is a global variable

def my_function():
print(x)

my_function()
print(x) # This will print the value of 'x' because it's a global variable.
```

**When to Choose Local vs. Global Variables**:

1. **Local Variables**:

- Use local variables when you need temporary storage for data that is specific to a particular
function or block. They help encapsulate data within a specific context, preventing unintended
interactions or modifications from other parts of the program.

- Local variables are typically preferred for function-specific computations or when you want
to avoid naming conflicts with variables in other parts of your code.

2. **Global Variables**:

- Use global variables when you need to share data between multiple functions or across
different parts of your program. They provide a way to maintain state and data that is accessible
throughout the program's execution.
 - Be cautious with global variables as they can make it harder to understand and debug your
code, especially in larger programs. It's essential to use them judiciously and document their
purpose.

In practice, it's a good practice to limit the use of global variables and prefer local variables when
possible to keep your code modular and maintainable. However, global variables are useful for
storing configuration settings, constants, or shared data that needs to be accessed across different
functions and modules.

Ans 20:-Reserved words, also known as keywords, in Python are a set of predefined and
reserved words that have special meanings and specific functions within the Python
programming language. These words are part of Python's syntax, and they cannot be used as
identifiers (variable names, function names, etc.) in your code. They are important for
maintaining the consistency and structure of the language and for indicating certain language
features.

Python has a relatively small number of reserved words, which makes it a beginner-friendly and
readable language. Examples of some common Python keywords include `if`, `else`, `while`,
`for`, `def`, `class`, and `import`.

**Importance of Keywords**:

1. **Syntax and Clarity**: Keywords define the syntax and structure of the language, making
Python code easy to read and understand. They indicate control flow, define functions and
classes, and import modules, among other essential language features.

2. **Prevent Naming Conflicts**: By reserving these words, Python ensures that they cannot be
accidentally redefined as variable names or function names. This helps avoid naming conflicts
that could lead to unexpected behavior.

3. **Consistency**: Keywords provide a consistent and standardized way of writing code in

Python. Developers can rely on a shared set of keywords and their defined behavior.

**Avoiding Naming Conflicts with Keywords**:

To avoid naming conflicts with keywords, follow these guidelines:

1. **Choose Descriptive Names**: Use variable and function names that are descriptive of their
purpose. This reduces the likelihood of accidentally using a reserved word.
2. **Avoid Built-in Names**: Avoid using names that are similar to built-in functions or types
(e.g., don't use names like `list`, `str`, or `int` for your variables). While not strictly reserved
words, using these names can lead to confusion.

3. **Use Underscores**: You can add underscores to variable names to improve readability and
reduce naming conflicts. For example, use `my_variable` instead of `variable`.

4. **Be Mindful of Scope**: Consider the scope of your variables and functions. Local variables
in a function have narrower scope than global variables, reducing the chance of conflicts.

5. **Follow Naming Conventions**: Adhere to Python's naming conventions, such as using

lowercase letters and underscores for variable names (e.g., `my_variable_name`) and following
the PEP 8 style guide.

6. **Use IDE or Code Editors**: Many integrated development environments (IDEs) and code
editors provide features that highlight reserved words or suggest variable names to prevent
conflicts.

7. **Static Code Analysis**: Use static code analysis tools that can detect naming conflicts or
suggest alternative names for your variables.

By following these practices, you can minimize the chances of accidentally naming your
variables, functions, or classes in a way that conflicts with Python's reserved words, helping to
maintain code clarity and avoid unintended errors.