• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
• Python Files I/O
  • File Handling Programs
  • File Handling MCQs
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Introduction

File handling in Python is a fundamental concept that allows you to read from and write to files on your computer.

Opening a file: To open a file, you can use the built-in open() function. It takes two arguments: the file path (including the file name) and the mode in which you want to open the file.

Different Modes to Open File.

In Python, file handling modes are used to specify the intended operation when opening a file. Each mode determines whether the file should be opened for reading, writing, appending, or exclusive creation. Here are the different modes in Python file handling without plagiarism:

1. Read Mode (‘r’):

This is the default mode when opening a file. It allows you to read the contents of an existing file. If the file does not exist, a `FileNotFoundError` will be raised.

				
   # Example:
   file = open('file.txt', 'r')
   content = file.read()
   file.close()

2. Write Mode (‘w’):

Write mode opens a file for writing. If the file exists, it truncates (empties) the file before writing to it. If the file does not exist, a new file is created. Be cautious because opening a file in write mode will erase its previous contents.

   
# Example:
   file = open('file.txt', 'w')
   file.write('Hello, world!n')
   file.close()	
		

3. Append Mode (‘a’):

Append mode opens a file for appending new data at the end. If the file exists, the data will be added to the existing content. If the file does not exist, a new file is created.

				
   # Example:
   file = open('file.txt', 'a')
   file.write('New linen')
   file.close()

4. Exclusive Creation Mode (‘x’):

Exclusive creation mode opens a file for writing but only if the file does not already exist. If the file exists, a `FileExistsError` is raised.

				
   # Example:
   try:
       file = open('file.txt', 'x')
       file.write('New file created')
       file.close()
   except FileExistsError:
       print("File already exists!")		

5. Binary Mode (‘b’):

Binary mode is an optional flag that can be added to any of the above modes. It is used when working with binary files, such as images or audio files. This mode ensures proper handling of binary data.

				
   # Example:
   # Opens a binary file in read mode
   file = open('image.jpg', 'rb') 
   content = file.read()
   file.close()	

Context Manager

A context manager in Python to open a file ensures that the file is automatically closed after use — even if an error occurs. This prevents resource leaks and makes the code cleaner.

It’s important to note that using the `with` statement is recommended when working with files, as it automatically takes care of closing the file, even if an exception occurs. Here’s an example using the `with` statement:

	
        # Perform operations on the file		
	with open('file.txt', 'r') as file:
              content = file.read()
              print(content)
   		

Different methods in Python File IO

1. `read()` method:

The `read()` method is used to read the entire contents of a file as a single string. Here’s an example:

	
	with open('file.txt', 'r') as file:
              content = file.read()
                print(content)

2. `readline()` method:

The `readline()` method is used to read a single line from a file. Here’s an example:

				
	with open('file.txt', 'r') as file:
             line = file.readline()
            print(line)

3. `readlines()` method:

The `readlines()` method reads all the lines of a file and returns them as a list of strings. Here’s an example:

				
     with open('file.txt', 'r') as file:
       	   lines = file.readlines()
       	   for line in lines:
           	print(line)

4. `write()` method:

The `write()` method is used to write a string to a file. Here’s an example:

				
	with open('file.txt', 'w') as file:
       	     file.write('Hello, world!n')

5. `writelines()` method:

The `writelines()` method is used to write a list of strings to a file, where each string represents a line. Here’s an example:

				
    lines = ['Line 1n', 'Line 2n', 'Line 3n']
   with open('file.txt', 'w') as file:
       	file.writelines(lines)

6. `seek()` method:

The `seek()` method is used to change the file’s current position to the given offset. Here’s an example:

				
	with open('file.txt', 'r') as file:
              # Moves the file pointer to the 6th character
       	      file.seek(5)  
       	      content = file.read()
       	      print(content)

7. `tell()` method:

The `tell()` method is used to return the current position of the file pointer. Here’s an example:

				
	with open('file.txt', 'r') as file:
       	       content = file.read(10)  # Reads the first 10 characters
       	       position = file.tell()  # Retrieves the current position
       	       print(position)
				

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
• Python Functions
  • Variables Scope
  • Function Programs
  • Function MCQs
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Python Function Introduction

A function in Python is a block of reusable code that performs a specific task. Functions help organize code, reduce repetition, and improve readability.

1. Why Use Functions?

✔ Avoid repeating code
✔ Break large programs into small logical pieces
✔ Improve readability and maintainability
✔ Make code scalable and easier to debug

2. Defining and Calling a Function

Syntax

def function_name(parameters):
    # code block
    return value

Example

def greet():
    print("Hello, welcome to Python!")
    
greet()     # Calling the function

3. Function with Parameters (Arguments)

def greet_user(name):
    print("Hello", name)

greet_user("John")

Output

Hello John

4. Function with Return Value

def add(x, y):
    return x + y

result = add(10, 5)
print(result)

Output

15

5. Default Parameters

If no value is passed, default will be used.

def info(country="India"):
    print("I am from", country)

info()
# output :   I am from India

info("Japan")
# output : I am from Japan

6. Keyword Arguments

Arguments can be passed using the parameter name.

def student(name, age):
    print(name, "is", age, "years old")

student(age=21, name="Riya")

# Output :  Riya is 21 year old.

7. Arbitrary Arguments (*args)

Used when you don’t know how many arguments will be passed.

def total_marks(*marks):
    print("Total:", sum(marks))

total_marks(80, 75, 90, 60)

# Output :  Total : 305

8. Arbitrary Keyword Arguments (**kwargs)

Accepts key-value pairs (dictionary-like).

def profile(**details):
    for key, value in details.items():
        print(key, ":", value)

profile(name="Amit", age=25, city="Delhi")

# Output :

name : Amit
age : 25
city : Delhi

9. Lambda (Anonymous) Functions

Short, one-line functions without a name.

square = lambda x: x * x
print(square(6))

# Output : 36

10. Nested Functions

Function inside another function.

def outer():
    print("Outer Function")
    
    def inner():
        print("Inner Function")
    
    inner()

outer()

11. Recursion (Function Calling Itself)

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5)) 

# Output : 120

12. Passing a Function as an Argument

def apply(func, value):
    return func(value)

def double(x):
    return x * 2

print(apply(double, 4))   # Output: 8

Best Practices

Docstring Example

def multiply(a, b):
    """Returns the product of two numbers"""
    return a * b

print(multiply.__doc__)

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
• Python Dictionary
  • Dictionary Programs
  • Dictionary MCQs
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Python Dictionary Introduction

Python dictionaries are a built-in data type used to store key-value pairs. They are mutable and allow for efficient retrieval and manipulation of data. Dictionaries are defined using curly braces ({}) and contain comma-separated key-value pairs. Here’s an example:

person = {
    "name": "Yash",
    "age": 23,
    "occupation": "Architect"
}

In this example, “name”, “age”, and “occupation” are the keys, and “Yash”, 23, and “Architect” are the corresponding values. The keys must be unique within a dictionary, but the values can be of any data type.

You can access the values in a dictionary by using the corresponding key:

print(person["name"])  # Output: Yash
print(person["age"])  # Output: 23
print(person["occupation"])  # Output: Architect

Features of Python Dictionary:

1. Key-Value Pairs: Python dictionaries are a collection of key-value pairs, where each key is unique and associated with a value.
2. Mutable: Dictionaries are mutable, which means you can modify, add, or remove key-value pairs after the dictionary is created.
3. Dynamic Sizing: Dictionaries in Python can dynamically resize to accommodate an arbitrary number of key-value pairs.
4. Unordered: Dictionaries are unordered, meaning the items are not stored in any particular order.
5. Efficient Data Retrieval: Dictionaries provide fast and efficient data retrieval based on the key.
6. Various Data Types: Python dictionaries can store values of any data type, including integers, floats, strings, lists, tuples, other dictionaries, and even custom objects. This flexibility allows you to organize and structure data in a way that suits your specific needs.
7. Membership Testing: Dictionaries provide efficient membership testing using the `in` operator. You can check if a key exists in a dictionary without iterating over all the items, making it convenient for conditional operations.
8. Uniqueness of Keys: Python dictionary keys must be unique. This property ensures that each key is associated with a single value, preventing duplicate entries

Python Dictionary Functions/Methods:

1. `len()` function: Returns the number of key-value pairs in a dictionary.

dictionary = {"name": "Yash", "age": 23}
print(len(dictionary))  # Output: 2

2. `keys()` method: Returns a view object that contains all the keys in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
keys = dictionary.keys()
print(keys) 
# Output: dict_keys(['name', 'age', 'occupation'])

3. `values()` method: Returns a view object that contains all the values in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
values = dictionary.values()
print(values)  
# Output: dict_values([Yash, 22,Architect])

4. `items()` method: Returns a view object that contains all the key-value pairs as tuples in a dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
items = dictionary.items()
print(items)  # Output: dict_items([('name', 'Yash'), ('age',23), ('occupation', 'Architect')])

5. `get()` method: Returns the value associated with a given key. It allows specifying a default value to be returned if the key is not found.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print(dictionary.get("name"))         # Output: Yash
print(my_dict.get("city", "N/A"))  # Output: N/A (default value for non-existent key)

6. `pop()` method: Removes and returns the value associated with a given key. It takes the key as an argument and removes the corresponding key-value pair from the dictionary.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
removed_value = dictionary.pop("age")
print(removed_value)  # Output : 25
print(dictionary)        # Output: {'name': 'Yash', 'occupation': 'Architect'}

7. `update()` method: Merges the key-value pairs from another dictionary into the current dictionary. If a key already exists, the value is updated; otherwise, a new key-value pair is added.

dictionary = {"name": "Yeah", "age": 23}
new_dict = {"occupation": "Architect", "city": "Pune"}
dictionary.update(new_dict)
print(dictionary)  # Output: {'name': 'Yash', 'age': 23, 'occupation': 'Architect', 'city': 'Pune'}

8. `clear()` method: Removes all key-value pairs from a dictionary, making it empty.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
dictionary.clear()
print(dictionary)  # Output: {}

Python Dictionary operators:

1. Membership Operators:

   – `in` operator: Returns `True` if a key exists in the dictionary, otherwise `False`.

   – `not in` operator: Returns `True` if a key does not exist in the dictionary, otherwise `False`.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
print("name" in dictionary)           # Output: True
print("Company" not in dictionary)       # Output: True
print("age" in dictionary.keys())     # Output: True
print("Engineer" in dictionary.values())  # Output: False

2. Comparison Operators:

   – `==` operator: Returns `True` if two dictionaries have the same key-value pairs, otherwise `False`.

   – `!=` operator: Returns `True` if two dictionaries have different key-value pairs, otherwise `False`.

dict1 = {"name": "Yash", "age": 23}
dict2 = {"age": 23, "name": "Yash"}

print(dict1 == dict2)  # Output: True (order of key-value pairs doesn't matter)
print(dict1 != dict2)  # Output: False (key-value pairs are the same)

3. Assignment Operator:

   – `=` operator: Assigns a dictionary to a variable.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}

4. Deletion Operator:

   – `del` operator: Deletes an entire dictionary or a specific key-value pair.

dictionary = {"name": "Yash", "age": 23, "occupation": "Architect"}
del dictionary ["age"]
print(dictionary)  # Output: {'name': 'Yash', 'occupation': 'Architect'}

• Python Features
• Python Installation
• PyCharm Configuration
• Python Variables
• Python Data Types
• Python If Else
• Python Loops
• Python Strings
• Python Lists
• Python Tuples
• Python List Vs Tuple
• Python Sets
  • Sets MCQs
  • Sets Programs
• Python Dictionary
• Python Functions
• Python Files I/O
• Read Write Excel
• Read Write JSON
• Read Write CSV
• Python OS Module
• Python Exceptions
• Python Datetime
• Python Collection Module
• Python Sys Module
• Python Decorator
• Python Generators
• Python OOPS
• Python Numpy Module
• Python Pandas Module
• Python Sqlite Module

Python Set Introduction:

In Python, a set is an unordered collection of unique elements. Sets are mutable and can be modified using various methods.

Creating Sets:

To create a set in Python, you can use curly braces `{}` or the built-in `set()` function. Here’s an example.

				
# Using curly braces
my_set = {1, 2, 3, 4, 5}

# Using set() function
my_set = set([1, 2, 3, 4, 5])
	

Features of Python Set:

1. Uniqueness: Sets are collections of unique elements. Each element appears only once in a set. If you try to add a duplicate element, it will be ignored.
2. Mutable: Sets are mutable, meaning you can modify them by adding or removing elements after they are created.
3. Unordered: Sets are unordered collections, which means the elements are not stored in any particular order. You cannot access elements by indexing or slicing.
4. Creation: Sets can be created using curly braces `{}` or the built-in `set()` function. For example.

				
my_set = {1, 2, 3}  # Using curly braces

my_set = set([1, 2, 3])  # Using set() function

5. Membership Testing: Sets provide an efficient way to test if an element exists in a set using the `in` operator. This operation has a constant-time complexity compared to lists or tuples.

				
my_set = {1, 2, 3}
print(1 in my_set)  # Output: True
print(5 in my_set)  # Output: False
			

6. Iteration: You can iterate over the elements of a set using a `for` loop, which will visit each element in an arbitrary order.

my_set = {1, 2, 3}
for element in my_set:
    print(element)		

Deleting Python set:

In Python, you can delete a set using the `del` keyword. Here’s an example of how to delete a set. Here’s an example:

				
my_set = {1, 2, 3, 4, 5}
# Deleting the set
del my_set

# Trying to access the set after deletion will raise an error
print(my_set)  # Raises NameError: name 'my_set' is not defined

In the example above, the `del` keyword is used to delete the `my_set` variable, which contains the set. After deleting the set, any attempt to access or use the set will result in a `NameError` because the set no longer exists.

Python Set operators:

1. Union: The union of two sets `A` and `B` contains all unique elements from both sets. In Python, you can perform the union operation using the `union()` method or the `|` operator.

				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union = set1.union(set2)  # Using method
union = set1 | set2  # Using operator
print(union)  # Output: {1, 2, 3, 4, 5}	
			

2. Intersection: The intersection of two sets `A` and `B` contains only the elements that are common to both sets. In Python, you can perform the intersection operation using the `intersection()` method or the `&` operator.

				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
intersection = set1.intersection(set2)  # Using method
intersection = set1 & set2  # Using operator
print(intersection)  # Output: {3}
			

3. Difference: The difference between two sets `A` and `B` contains the elements that are in `A` but not in `B`. In Python, you can perform the difference operation using the `difference()` method or the `-` operator.

				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
difference = set1.difference(set2)  # Using method
difference = set1 - set2  # Using operator
print(difference)  # Output: {1, 2}				
			

4. Symmetric Difference: The symmetric difference of two sets `A` and `B` contains the elements that are in either `A` or `B`, but not both. In Python, you can perform the symmetric difference operation using the `symmetric_difference()` method or the `^` operator.

				
set1 = {1, 2, 3}
set2 = {3, 4, 5}
symmetric_difference = set1.symmetric_difference(set2)  # Using method
symmetric_difference = set1 ^ set2  # Using operator
print(symmetric_difference)  # Output: {1, 2, 4, 5}
	

Python Set functions:

1. len(): The `len()` function returns the number of elements in a set.

		
my_set = {1, 2, 3, 4, 5, 6}
length = len(my_set)
print(length)  # Output: 6	
			

2. add(): The `add()` method adds an element to a set.

		
my_set = {1, 2, 3, 4}
my_set.add(5)
print(my_set)  # Output: {1, 2, 3, 4, 5}

3. remove(): The `remove()` method removes an element from a set. It raises a KeyError if the element does not exist in the set.

				
my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)  # Output: {1, 2, 4}
			

4. discard(): The `discard()` method removes an element from a set if it exists. It does not raise an error if the element is not found.

				
my_set = {1, 2, 3, 4}
my_set.discard(4)
print(my_set)  # Output: {1, 2, 3}
			

5. pop(): The `pop()` method removes and returns an arbitrary element from the set. Since sets are unordered, the popped element is not guaranteed to be the first or last element.

my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)  # Output: a random element, e.g., 1
print(my_set)  # {2, 3, 4}

6. clear(): The `clear()`method removes all elements from a set, making it empty.

				
my_set = {1, 2, 3, 4}
my_set.clear()
print(my_set)  # Output: set()	
			

7. copy(): The `copy()` method creates a shallow copy of a set, allowing you to work with a separate copy of the original set.

				
my_set = {1, 2, 3}
my_set_new = my_set.copy()
print(my_set_new)  # Output: {1, 2, 3}