Data Type in Python:
In Python, data types represent the kind of value a variable can hold. Python is a dynamically typed language, which
means you don't need to explicitly declare the data type of a variable; the interpreter determines the type
dynamically during runtime. Here are some common data types in Python:
1. **Numeric Types:**
- **int:** Integer type (e.g., 1, -5, 1000)
- **float:** Floating-point type (e.g., 3.14, -2.5, 0.0)
```python
# Numeric types
integer_variable = 10
float_variable = 3.14
```
2. **Sequence Types:**
- **str:** String type (e.g., "hello", 'world')
- **list:** List type (e.g., [1, 2, 3], ['a', 'b', 'c'])
- **tuple:** Tuple type (e.g., (1, 2, 3), ('x', 'y', 'z'))
```python
# Sequence types
string_variable = "Hello, World!"
list_variable = [1, 2, 3]
tuple_variable = (4, 5, 6)
```
3. **Set Types:**
- **set:** Set type (e.g., {1, 2, 3}, {'apple', 'orange', 'banana'})
```python
# Set type
set_variable = {1, 2, 3}
```
4. **Mapping Type:**
- **dict:** Dictionary type (e.g., {'key1': 'value1', 'key2': 'value2'})
```python
# Dictionary type
dictionary_variable = {'name': 'John', 'age': 25, 'city': 'New York'}
```
5. **Boolean Type:**
- **bool:** Boolean type (True or False)
```python
# Boolean type
boolean_variable = True
```
6. **None Type:**
- **NoneType:** Represents the absence of a value or a null value.
```python
# None type
none_variable = None
```
7. **Other Types:**
- **complex:** Complex number type (e.g., 1 + 2j)
```python
# Complex number type
complex_variable = 1 + 2j
```
These are the fundamental data types in Python. Additionally, Python supports a wide range of libraries and modules
that introduce more specialized data types for various purposes.
Recursion (Local + Global) in Python:
### Local Recursion:
#### 1. Factorial Calculation:
```python
def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n-1)
result = factorial(5)
print(f"The factorial of 5 is: {result}")
```
#### 2. Fibonacci Sequence:
```python
def fibonacci(n):
if n <= 1:
return n
else:
return fibonacci(n-1) + fibonacci(n-2)
for i in range(6):
print(f"Fibonacci({i}) = {fibonacci(i)}")
```
### Global Recursion:
#### 1. Tower of Hanoi:
```python
def tower_of_hanoi(n, source, auxiliary, target):
if n > 0:
# Move n-1 disks from source to auxiliary peg
tower_of_hanoi(n-1, source, target, auxiliary)
# Move the nth disk from source to target peg
print(f"Move disk {n} from {source} to {target}")
# Move the n-1 disks from auxiliary to target peg
tower_of_hanoi(n-1, auxiliary, source, target)
# Example: Move 3 disks from peg A to peg C using peg B as auxiliary
tower_of_hanoi(3, 'A', 'B', 'C')
```
#### 2. Binary Search:
```python
def binary_search(arr, target, low, high):
if low <= high:
mid = (low + high) // 2
if arr[mid] == target:
return mid
elif arr[mid] < target:
return binary_search(arr, target, mid + 1, high)
else:
return binary_search(arr, target, low, mid - 1)
else:
return -1
# Example: Search for 5 in a sorted list
sorted_list = [1, 3, 5, 7, 9, 11, 13, 15]
result = binary_search(sorted_list, 5, 0, len(sorted_list) - 1)
if result != -1:
print(f"Element found at index {result}")
else:
print("Element not found in the list")
```
These examples showcase both local and global recursion in Python. The local recursion is demonstrated by functions
calling themselves, while the global recursion involves multiple functions calling each other in a recursive manner.
Lists in Python:
In Python, the term "array" is often used to refer to lists. A list is a versatile, built-in data structure in Python that can
be used to store an ordered collection of items. Lists can hold elements of different data types and can be modified
after creation. Here's a basic overview of working with arrays (lists) in Python:
### Creating Lists:
You can create a list by enclosing elements in square brackets `[]` and separating them with commas.
```python
my_list = [1, 2, 3, 4, 5]
mixed_list = [1, 'hello', 3.14, True]
empty_list = []
```
### Accessing Elements:
You can access individual elements in a list using index notation. Python uses zero-based indexing.
```python
print(my_list[0]) # Output: 1
print(mixed_list[1]) # Output: 'hello'
```
### Modifying Lists:
Lists are mutable, meaning you can modify their contents.
```python
my_list[2] = 10
print(my_list) # Output: [1, 2, 10, 4, 5]
```
### List Operations:
```python
# Concatenation
new_list = my_list + mixed_list
# Repetition
repeated_list = my_list * 2
# Length
length = len(my_list)
# Check if an element is in the list
is_present = 3 in my_list
```
### List Methods:
Python provides several built-in methods for working with lists:
```python
my_list.append(6) # Add an element to the end
my_list.insert(2, 7) # Insert an element at a specific index
my_list.remove(4) # Remove the first occurrence of a value
popped_value = my_list.pop() # Remove and return the last element
my_list.sort() # Sort the list in ascending order
my_list.reverse() # Reverse the order of elements
```
### Slicing:
You can extract a sublist (slice) from a list using slicing notation.
```python
subset = my_list[1:4] # Elements at index 1, 2, and 3
```
Lists in Python are dynamic and can be modified easily. If you need more advanced features like mathematical
operations on arrays or fixed-size arrays, you might want to explore the `numpy` library, which provides powerful
array manipulation capabilities.
Iteration in Python:
Iteration is a process of repeatedly executing a set of statements or a block of code. In Python, there are several ways
to perform iteration. Here are some common methods:
### 1. **For Loop:**
The `for` loop is used to iterate over a sequence (such as a list, tuple, string, or range).
```python
# Iterate over a list
fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
print(fruit)
```
```python
# Iterate over a range of numbers
for i in range(1, 5):
print(i)
```
### 2. **While Loop:**
The `while` loop continues to execute a block of code as long as a specified condition is true.
```python
# While loop to print numbers from 1 to 5
i=1
while i <= 5:
print(i)
i += 1
```
### 3. **Iterating Over Elements and Indices:**
You can use the `enumerate` function to iterate over both elements and their indices in a sequence.
```python
fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
print(f"Index: {index}, Fruit: {fruit}")
```
### 4. **Iterating Over Dictionaries:**
You can iterate over the keys, values, or key-value pairs of a dictionary.
```python
person = {'name': 'John', 'age': 30, 'city': 'New York'}
for key, value in person.items():
print(f"{key}: {value}")
```
### 5. **List Comprehensions:**
List comprehensions provide a concise way to create lists and perform iteration in a single line.
```python
squares = [x**2 for x in range(1, 6)]
print(squares) # Output: [1, 4, 9, 16, 25]
```
### 6. **Break and Continue:**
The `break` statement is used to exit a loop prematurely, and the `continue` statement skips the rest of the code
inside the loop for the current iteration.
```python
# Using break
for i in range(1, 10):
if i == 5:
break
print(i)
```
```python
# Using continue
for i in range(1, 6):
if i == 3:
continue
print(i)
```
These are some of the common ways to perform iteration in Python. Depending on the context, you may choose the
most suitable method for your specific requirements.
String in Python:
In Python, a string is a sequence of characters. Strings are one of the fundamental data types and are commonly used
for storing and manipulating textual data. Here are some basic operations and concepts related to strings in Python:
### Creating Strings:
You can create a string by enclosing characters within single (`'`) or double (`"`) quotes.
```python
str1 = 'Hello, World!'
str2 = "Python is fun."
```
### String Operations:
1. **Concatenation:**
```python
concatenated_str = str1 + ' ' + str2
print(concatenated_str)
```
2. **Repetition:**
```python
repeated_str = str1 * 3
print(repeated_str)
```
3. **Indexing:**
Strings are indexed, starting from 0.
```python
first_char = str1[0]
last_char = str1[-1]
```
4. **Slicing:**
You can extract a substring using slicing notation.
```python
substring = str1[0:5] # Characters at index 0, 1, 2, 3, and 4
```
5. **String Length:**
```python
length = len(str1)
```
6. **String Methods:**
Python provides many built-in methods for working with strings.
```python
upper_case = str1.upper()
lower_case = str1.lower()
is_alpha = str1.isalpha()
```
### Escape Characters:
You can use escape characters to include special characters in a string.
```python
escaped_str = "This is a \"quoted\" string."
new_line_str = "This is a line\nbreak."
```
### String Formatting:
String formatting allows you to create dynamic strings.
```python
name = "John"
age = 25
formatted_str = "My name is {} and I'm {} years old.".format(name, age)
```
In Python 3.6 and above, you can use f-strings for a more concise way of formatting:
```python
formatted_str = f"My name is {name} and I'm {age} years old."
```
### String Methods:
Python provides a rich set of methods for string manipulation. Some commonly used methods include:
- `str.upper()`: Converts all characters in the string to uppercase.
- `str.lower()`: Converts all characters in the string to lowercase.
- `str.strip()`: Removes leading and trailing whitespaces.
- `str.split()`: Splits the string into a list of substrings.
- `str.find()`: Returns the index of the first occurrence of a substring.
- `str.replace()`: Replaces a specified substring with another substring.
```python
text = "Hello, world!"
uppercase_text = text.upper()
split_text = text.split(", ")
```
These are just some basics of working with strings in Python. Strings are a versatile and essential part of Python
programming, and there's much more you can do with them.
Inheritance in Python:
Certainly! Here's an example of inheritance in Python with a simple program involving a base class (`Person`) and two
derived classes (`Student` and `Teacher`):
```python
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
def display_info(self):
return f"Name: {self.name}, Age: {self.age}"
class Student(Person):
def __init__(self, name, age, student_id):
# Call the constructor of the base class
super().__init__(name, age)
self.student_id = student_id
def display_info(self):
# Override the display_info method
return f"Student ID: {self.student_id}, {super().display_info()}"
class Teacher(Person):
def __init__(self, name, age, employee_id):
# Call the constructor of the base class
super().__init__(name, age)
self.employee_id = employee_id
def display_info(self):
# Override the display_info method
return f"Employee ID: {self.employee_id}, {super().display_info()}"
# Create instances of derived classes
student = Student(name="Alice", age=20, student_id="S12345")
teacher = Teacher(name="Mr. Smith", age=35, employee_id="T98765")
# Display information using overridden methods
print(student.display_info())
print(teacher.display_info())
```
In this example:
- `Person` is the base class with common attributes (`name` and `age`) and a method (`display_info`) to display
information.
- `Student` and `Teacher` are derived classes that inherit from the `Person` class. They both have additional attributes
(`student_id` and `employee_id`, respectively) and override the `display_info` method to include their specific
information.
- The `super()` function is used to call the constructor and methods of the base class.
When you run this program, you will see that instances of `Student` and `Teacher` can access both the attributes and
methods of the `Person` class while having their specific attributes and methods.
Encapsulation in python:
Encapsulation is one of the fundamental principles of object-oriented programming, emphasizing the bundling of
data and methods that operate on that data within a single unit, known as a class. Here's an example of
encapsulation in Python:
```python
class Student:
def __init__(self, name, age, student_id):
# Private attributes
self.__name = name
self.__age = age
self.__student_id = student_id
# Public methods to access private attributes
def get_name(self):
return self.__name
def get_age(self):
return self.__age
def get_student_id(self):
return self.__student_id
# Public method to modify private attribute
def set_age(self, new_age):
if 0 < new_age < 120:
self.__age = new_age
else:
print("Invalid age value")
# Display information about the student
def display_info(self):
print(f"Student ID: {self.__student_id}, Name: {self.__name}, Age: {self.__age}")
# Create an instance of the Student class
student1 = Student(name="Alice", age=20, student_id="S12345")
# Accessing attributes using public methods
print("Name:", student1.get_name())
print("Age:", student1.get_age())
print("Student ID:", student1.get_student_id())
# Modifying attribute using public method
student1.set_age(21)
# Display information
student1.display_info()
```
In this example:
- The attributes (`__name`, `__age`, `__student_id`) are encapsulated as they are private and can only be accessed or
modified through public methods (`get_name`, `get_age`, `get_student_id`, `set_age`).
- The `set_age` method ensures that the age is within a valid range before modifying the attribute.
- The `display_info` method provides a way to display information about the student while encapsulating the internal
details of the class.
This encapsulation ensures that the internal state of the `Student` class is protected and can only be accessed or
modified through well-defined interfaces, promoting data integrity and security.
Exception handling in Python:
Exception handling is a crucial aspect of programming to handle runtime errors and unexpected situations. Here are
some Python programs that demonstrate different aspects of exception handling:
### 1. Basic Exception Handling:
```python
try:
x = 10 / 0 # Division by zero
except ZeroDivisionError as e:
print(f"Error: {e}")
else:
print("No exception occurred.")
finally:
print("Finally block always executed.")
```
### 2. Custom Exception:
```python
class CustomError(Exception):
def __init__(self, message):
self.message = message
try:
raise CustomError("This is a custom exception.")
except CustomError as ce:
print(f"Custom Error: {ce.message}")
```
### 3. Handling Multiple Exceptions:
```python
try:
num1 = int(input("Enter a number: "))
num2 = int(input("Enter another number: "))
result = num1 / num2
except ValueError:
print("Invalid input. Please enter a valid number.")
except ZeroDivisionError:
print("Cannot divide by zero.")
else:
print(f"Result: {result}")
```
### 4. Using `finally` without `except`:
```python
try:
file = open("nonexistent_file.txt", "r")
except FileNotFoundError:
print("File not found.")
finally:
print("This block always executed, even if there is no exception.")
```
### 5. Handling Multiple Exceptions in One `except` Block:
```python
try:
x = 10 / 0 # Division by zero
except (ZeroDivisionError, NameError, TypeError) as e:
print(f"Error: {e}")
```
### 6. Raising Exceptions:
```python
try:
age = int(input("Enter your age: "))
if age < 0:
raise ValueError("Age cannot be negative.")
except ValueError as ve:
print(f"Error: {ve}")
```These examples cover a range of scenarios for handling exceptions in Python. Understanding and using exception
handling effectively can make your programs more robust and resilient to unexpected issues.
File handling in Python:
### 1. Writing to a File:
```python
# Writing to a file
with open("example.txt", "w") as file:
file.write("Hello, this is a sample file.\n")
file.write("Python is awesome!\n")
```
### 2. Reading from a File:
```python
# Reading from a file
with open("example.txt", "r") as file:
content = file.read()
print("File Content:\n", content)
```
### 3. Appending to a File:
```python
# Appending to a file
with open("example.txt", "a") as file:
file.write("Appending new content to the file.\n")
```
### 4. Reading Line by Line:
```python
# Reading line by line
with open("example.txt", "r") as file:
lines = file.readlines()
print("Lines in the File:")
for line in lines:
print(line.strip())
```
### 5. Handling Exceptions during File Operations:
```python
try:
with open("nonexistent_file.txt", "r") as file:
content = file.read()
print(content)
except FileNotFoundError:
print("File not found.")
except Exception as e:
print(f"An error occurred: {e}")
```
### 6. Copying a File:
```python
source_file = "example.txt"
destination_file = "copy_of_example.txt"
try:
with open(source_file, "r") as source, open(destination_file, "w") as dest:
content = source.read()
dest.write(content)
print(f"File '{source_file}' copied to '{destination_file}'.")
except FileNotFoundError:
print("Source file not found.")
except Exception as e:
print(f"An error occurred: {e}")
```
### 7. Using `with` Statement for Multiple Files:
```python
with open("file1.txt", "r") as file1, open("file2.txt", "r") as file2:
content1 = file1.read()
content2 = file2.read()
print("Content of file1:\n", content1)
print("Content of file2:\n", content2)
```
These examples cover basic file handling operations such as reading, writing, appending, and handling exceptions
during file operations. Depending on your requirements, you can adapt and extend these examples for more complex
scenarios.
