Internship Report :

Working as python programming at

NUTURE TECHNOLOGY
By
G. KEERTHIK
21bsit215
[email protected]
Performed at
NUTURE TECHNOLOGY
ERODE GH, NEAR ERODE BUS STAND
In partial fulfillment of the requirements of
the Python programming
 SRI KRISHNA ADTIHYA COLLEGE
OF ARTS AND SCIENCE
Report of Internship for the period June 5-
June 11-2025
Tile of the content
1. Introduction about python
Operators
2. Data types an variables
3. Operators
4. Decision making
5. Loops
CERTIFICATE
INTRODUCTION OF PYTHON:
Python is a high-level, interpreted programming language that is widely used in various domains
such as web development, data science, automation, artificial intelligence, and software
development. It was created by Guido van Rossum and first released in 1991. Python's
simplicity and readability make it an ideal choice for both beginners and experienced developers.

During my internship, Python played a crucial role in solving real-world problems efficiently. Its
extensive libraries, frameworks, and ease of integration with other technologies contributed
significantly to the development of various applications.

Key Features of Python:

 Simple and Readable: Python’s syntax is easy to understand and write, which enhances
productivity.
 Interpreted Language: Python code runs line by line, making debugging easier.
 Dynamically Typed: No need to declare variable types explicitly.
 Extensive Libraries: A vast collection of built-in and third-party libraries for tasks like
data processing, machine learning, and web development.
 Cross-Platform Compatibility: Python can run on Windows, Linux, and macOS
without modification.
 Object-Oriented Programming (OOP): Supports OOP concepts such as classes and
objects, improving code reusability.

Applications of Python in My Internship:

During my internship, Python was used in various aspects of the project, including:

 Data Analysis: Processing and analyzing large datasets using Pandas and NumPy.
 Automation: Writing scripts to automate repetitive tasks.
 Web Development: Using Django and Flask for backend development.
 Machine Learning: Implementing predictive models using TensorFlow and Scikit-
Learn.

Python’s flexibility and efficiency made it a valuable tool during my internship, enabling me to
develop scalable and optimized solutions.

DATA TYPES ANDVARIABLES:

1. Introduction
During my internship, I had the opportunity to work with Python programming, particularly
focusing on the fundamental concepts of data types and variables. Understanding these concepts
is crucial for effective programming as they define how data is stored, manipulated, and utilized
in Python applications.

2. Understanding Variables in Python

A variable in Python is a named memory location used to store data. Variables are dynamically
typed, meaning they do not require explicit declaration. The type of a variable is inferred based
on the assigned value. For example:

x = 10 # Integer variable
y = 3.14 # Floating-point variable
name = "John" # String variable

3. Data Types in Python

Python provides several built-in data types categorized as follows:

a. Numeric Types

 int: Represents integer values (e.g., x = 100)

 float: Represents floating-point numbers (e.g., y = 10.5)
 complex: Represents complex numbers (e.g., z = 2 + 3j)

b. Sequence Types

 str: Represents a sequence of characters (e.g., name = "Alice")

 list: Mutable sequence of elements (e.g., fruits = ["apple", "banana",
"cherry"])
 tuple: Immutable sequence of elements (e.g., coordinates = (10, 20))

c. Set Types

 set: Unordered collection of unique elements (e.g., unique_nums = {1, 2, 3, 4})

 frozenset: Immutable version of a set

d. Mapping Type

 dict: Key-value pairs (e.g., student = {"name": "John", "age": 20})

e. Boolean Type

 bool: Represents True or False values (e.g., status = True)

f. None Type

 NoneType: Represents a null value (e.g., value = None)

4. Variable Naming Rules and Best Practices

  Variable names must start with a letter or an underscore (_), followed by letters, digits, or
underscores.
 Variable names are case-sensitive (Name and name are different variables).
 Descriptive variable names improve code readability (e.g., student_age instead of sa).
 Avoid using Python keywords as variable names (e.g., class = 10 is invalid).

5. Type Conversion
Python allows type conversion between different data types using built-in functions:

x = 5 # Integer
y = float(x) # Converts to float
txt = "100"
num = int(txt) # Converts string to integer

6. Scope and Lifetime of Variables

 Variables inside a function are local and exist only within the function scope.
 Variables defined outside functions are global and accessible throughout the script.
 global and nonlocal keywords help manage variable scopes inside nested functions.

O
\

3.OPERATORS IN PYTHON
1. Introduction
During my internship, I had the
opportunity to work with Python
programming, particularly focusing on
the fundamental concepts of operators.
Operators are essential in Python as they
allow us to perform various operations on
variables and values.

**2. Types of Operators in Python**

Python provides several types of
operators categorized as follows:

**a. Arithmetic Operators**

These operators perform mathematical
operations:
```python
x = 10
y=5
print(x + y) # Addition
print(x - y) # Subtraction
print(x * y) # Multiplication
print(x / y) # Division
print(x % y) # Modulus
print(x ** y) # Exponentiation
print(x // y) # Floor division
```

b. Comparison Operators
Used to compare two values and return a
Boolean result:
```python
a = 10
b=5
print(a == b) # Equal to
print(a != b) # Not equal to
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to
```

**c. Logical Operators**

Used to combine conditional statements:
```python
x = True
y = False
print(x and y) # Logical AND
print(x or y) # Logical OR
print(not x) # Logical NOT
```

**d. Bitwise Operators**

Perform bit-level operations:
```python
a = 5 # 0101
b = 3 # 0011
print(a & b) # AND
print(a | b) # OR
print(a ^ b) # XOR
print(~a) # NOT
print(a << 1) # Left shift
print(a >> 1) # Right shift
```

e. Assignment Operators
Used to assign values to variables:
```python
x = 10
x += 5 # Equivalent to x = x + 5
x -= 3 # Equivalent to x = x - 3
x *= 2 # Equivalent to x = x * 2
x /= 4 # Equivalent to x = x / 4
x %= 3 # Equivalent to x = x % 3
x **= 2 # Equivalent to x = x ** 2
x //= 2 # Equivalent to x = x // 2
```
f. Membership Operators
Used to check if a value exists in a
sequence:
```python
numbers = [1, 2, 3, 4, 5]
print(3 in numbers) # Returns True
print(6 not in numbers) # Returns True
```

**g. Identity Operators**

Used to compare memory locations of
objects:
```python
a = 10
b = 10
print(a is b) # Returns True
print(a is not b) # Returns False
```

3. Conclusion
Operators are fundamental to Python
programming as they allow us to perform
calculations, comparisons, and logical
operations. Throughout my internship, I
explored how operators help in writing
efficient and concise code. Mastering
these concepts is crucial for building more
complex applications and improving
problem-solving skill
**INTERNSHIP REPORT**
**OPERATORS IN PYTHON**
**1. Introduction**
During my internship, I had the
opportunity to work with Python
programming, particularly focusing on
the fundamental concepts of operators.
Operators are essential in Python as they
allow us to perform various operations on
variables and values.

**2. Types of Operators in Python**

Python provides several types of
operators categorized as follows:

**a. Arithmetic Operators**

These operators perform mathematical
operations:
```python
x = 10
y=5
print(x + y) # Addition
print(x - y) # Subtraction
print(x * y) # Multiplication
print(x / y) # Division
print(x % y) # Modulus
print(x ** y) # Exponentiation
print(x // y) # Floor division
```

**b. Comparison Operators**

Used to compare two values and return a
Boolean result:
```python
a = 10
b=5
print(a == b) # Equal to
print(a != b) # Not equal to
print(a > b) # Greater than
print(a < b) # Less than
print(a >= b) # Greater than or equal to
print(a <= b) # Less than or equal to
```

**c. Logical Operators**

Used to combine conditional statements:
```python
x = True
y = False
print(x and y) # Logical AND
print(x or y) # Logical OR
print(not x) # Logical NOT
```

**d. Bitwise Operators**

Perform bit-level operations:
```python
a = 5 # 0101
b = 3 # 0011
print(a & b) # AND
print(a | b) # OR
print(a ^ b) # XOR
print(~a) # NOT
print(a << 1) # Left shift
print(a >> 1) # Right shift
```

**e. Assignment Operators**

Used to assign values to variables:
```python
x = 10
x += 5 # Equivalent to x = x + 5
x -= 3 # Equivalent to x = x - 3
x *= 2 # Equivalent to x = x * 2
x /= 4 # Equivalent to x = x / 4
x %= 3 # Equivalent to x = x % 3
x **= 2 # Equivalent to x = x ** 2
x //= 2 # Equivalent to x = x // 2
```

**f. Membership Operators**

Used to check if a value exists in a
sequence:
```python
numbers = [1, 2, 3, 4, 5]
print(3 in numbers) # Returns True
print(6 not in numbers) # Returns True
```

**g. Identity Operators**

Used to compare memory locations of
objects:
```python
a = 10
b = 10
print(a is b) # Returns True
print(a is not b) # Returns False
```

3. Conclusion
Operators are fundamental to Python
programming as they allow us to perform
calculations, comparisons, and logical
operations. Throughout my internship, I
explored how operators help in writing
efficient and concise code. Mastering
these concepts is crucial for building more
complex applications and improving
problem-solving skills.
4. **INTERNSHIP REPORT**
4.DECISION MAKING IN PYTHON

1. Introduction
During my internship, I had the
opportunity to work with Python
programming, particularly focusing on
decision-making concepts. Decision-
making is a crucial aspect of
programming that allows programs to
execute different blocks of code based on
conditions.

2. Decision-Making Statements in Python

Python provides several decision-making
statements to control the flow of execution
based on conditions:

a. if Statement
The `if` statement executes a block of
code only if a specified condition is
`True`:
```python
x = 10
if x > 5:
print("x is greater than 5")
```

**b. if-else Statement**

The `if-else` statement executes one block
of code if the condition is `True`,
otherwise, it executes another block:
```python
x = 10
if x > 15:
print("x is greater than 15")
else:
print("x is not greater than 15")
```

**c. if-elif-else Statement**

The `if-elif-else` statement allows multiple
conditions to be checked sequentially:
```python
x = 10
if x > 20:
print("x is greater than 20")
elif x > 10:
print("x is greater than 10 but not
greater than 20")
else:
print("x is 10 or less")
```

**d. Nested if Statement**

A nested `if` statement allows one `if`
condition to be inside another:
```python
x = 30
if x > 10:
 print("x is greater than 10")
if x > 20:
print("x is also greater than 20")
```

**e. Short-Hand if Statement**

A single-line `if` statement can be used for
simple conditions:
```python
x=5
if x > 3: print("x is greater than 3")
```

**f. Short-Hand if-else (Ternary

Operator)**
Python provides a concise way to write
`if-else` statements:
```python
x = 10
y = 20
print("x is greater") if x > y else print("y
is greater")
```

**3. Logical Operators in Decision

Making**
Logical operators (`and`, `or`, `not`) help
in combining multiple conditions:
```python
x = 10
y=5
if x > 5 and y < 10:
print("Both conditions are True")
```

4. Practical Applications
Decision-making statements are widely
used in applications such as:
- User authentication systems
- Menu-driven programs
- Data validation
- Game logic development

5. Conclusion
Decision-making is a fundamental
concept in Python programming, allowing
dynamic execution of code based on
conditions. Throughout my internship, I
explored various decision-making
statements and their practical
applications, which strengthened my
problem-solving skills and coding