• 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
• 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

NumPy is a fundamental library in Python used for scientific computing and data analysis. It stands for “Numerical Python” and provides powerful tools for working with multi-dimensional arrays and matrices, along with a vast collection of mathematical functions to operate on these arrays efficiently.

Slicing and Indexing using the NumPy library

Slicing and indexing are fundamental operations in NumPy that allow you to access and manipulate specific elements or subsets of an array.

Indexing:

1. Single Element: You can access a single element of an array by specifying its index using square brackets.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr[0])

# Output: 1

2. Multiple Elements: You can access multiple elements of an array by passing a list or an array of indices inside the square brackets.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
indices = [0, 2, 4]
print(arr[indices])

# Output: [1 3 5]

Slicing:

1. Basic Slicing: You can use slicing to extract a portion of an array by specifying the start and end indices, separated by a colon inside the square brackets.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])

# Elements from index 1 to 3 (exclusive)
sliced_arr = arr[1:4]
print(sliced_arr)

# Output: [2 3 4]

2. Step Slicing: You can specify a step value to slice every nth element from the array.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])

# Elements with a step of 2
sliced_arr = arr[::2]
print(sliced_arr)

# Output: [1 3 5]

3. Negative Indices: Negative indices allow you to slice from the end of the array.

import numpy as np
arr = np.array([1, 2, 3, 4, 5])

# Elements from the third-last to the second-last
sliced_arr = arr[-3:-1]
print(sliced_arr)

# Output: [3 4]

4. Slicing Multi-dimensional Arrays: You can slice multi-dimensional arrays using multiple indexing and slicing operations.

import numpy as np
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Rows from index 1 onwards, columns up to index 1 (exclusive)
sliced_arr = arr[1:, :2]
print(sliced_arr)

# Output:
[[4 5]
[7 8]]

Python Numpy functions

1. np.array(): Create a NumPy array from a Python list or tuple.
   Syntax: np.array(object, dtype=None, copy=True, order=’K’, subok=False, ndmin=0)

# Example:
import numpy as np

# Create a NumPy array from a Python list
my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)
print(my_array)

# Output: [1 2 3 4 5]

2. np.arange(): Create an array with evenly spaced values.
   Syntax: np.arange([start,] stop[, step,], dtype=None)

# Example:
import numpy as np

# Create an array with values from 0 to 9
my_array = np.arange(10)
print(my_array)

# Output: [0 1 2 3 4 5 6 7 8 9]

3. np.zeros(): Create an array filled with zeros.
   Syntax: np.zeros(shape, dtype=float, order=’C’)

# Example:
import numpy as np

# Create a 1D array filled with zeros
my_array = np.zeros(5)
print(my_array)

# Output: [0. 0. 0. 0. 0.]

4. np.ones(): Create an array filled with ones.
   Syntax: np.ones(shape, dtype=None, order=’C’)

# Example:
import numpy as np
# Create a 2D array filled with ones
my_array = np.ones((3, 2))
print(my_array)
# Output:
# [[1. 1.]
# [1. 1.]
# [1. 1.]]

5. np.linspace(): Create an array with a specified number of evenly spaced values.
   Syntax: np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

# Example:
import numpy as np

# Create an array with 5 evenly spaced values between 0 and 1
my_array = np.linspace(0, 1, 5)
print(my_array)

# Output: [0. 0.25 0.5 0.75 1. ]

6. np.eye(): Create an identity matrix.
   Syntax: np.eye(N, M=None, k=0, dtype=float, order=’C’)

# Example:
import numpy as np

# Create a 3×3 identity matrix
my_array = np.eye(3)
print(my_array)

# Output:
# [[1. 0. 0.]
# [0. 1. 0.]
# [0. 0. 1.]]

7. np.random.rand(): Generate random values from a uniform distribution.
   Syntax: np.random.rand(d0, d1, …, dn)

# Example:
import numpy as np

# Generate a 2×2 array of random values from a uniform distribution
my_array = np.random.rand(2, 2)
print(my_array)

# Output:
[[0.64822645 0.03382209]
[0.45753694 0.67940323]]

8. np.random.randn(): Generate random values from a standard normal distribution.
   Syntax: np.random.randn(d0, d1, …, dn)

# Example::
import numpy as np

# Generate a 3×3 array of random values from a standard normal distribution
my_array = np.random.randn(3, 3)
print(my_array)

# Output:
[[ 0.21372011 -0.76571721 0.54756781]
[ 0.95714164 -0.12939294 -0.57725997]
[-0.28264262 -0.45355784 -0.33564826]]

9. np.random.randint(): Generate random integers within a specified range.
   Syntax: np.random.randint(low, high=None, size=None, dtype=int)

# Example:
import numpy as np

# Generate a 1D array of 5 random integers between 0 and 9
my_array = np.random.randint(0, 10, 5)
print(my_array)

# Output:
[4 7 1 2 9]

       10. np.shape():  Get the dimensions of an array. Syntax: np.shape(array)

# Example:
import numpy as np

# Get the dimensions of an array
my_array = np.array([[1, 2, 3], [4, 5, 6]])
shape = np.shape(my_array)
print(shape)

# Output: (2, 3)

11. np.reshape(): Reshape an array to a specified shape.
    Syntax: np.reshape(array, newshape, order=’C’)

# Example::
import numpy as np

# Reshape a 1D array into a 2D array
my_array = np.array([1, 2, 3, 4, 5, 6])
reshaped_array = np.reshape(my_array, (2, 3))
print(reshaped_array)

# Output:
[[1 2 3]
[4 5 6]]

12. np.concatenate(): Join arrays along a specified axis.
    Syntax: np.concatenate((array1, array2, …), axis=0)

# Example::
import numpy as np

# Concatenate two arrays along the first axis
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6]])
concatenated_array = np.concatenate((array1, array2), axis=0)
print(concatenated_array)

# Output:
[[1 2]
[3 4]
[5 6]]

13. np.split(): Split an array into multiple sub-arrays.
    Syntax: np.split(array, indices_or_sections, axis=0)

# Example::
import numpy as np

# Split an array into three sub-arrays
my_array = np.array([1, 2, 3, 4, 5, 6])
split_array = np.split(my_array, 3)
print(split_array)

# Output:
[array([1, 2]), array([3, 4]), array([5, 6])]

14. np.max(): Find the maximum value in an array.
    Syntax: np.max(array, axis=None, out=None, keepdims=False, initial=None)

# Example::
import numpy as np

# Find the maximum value in an array
my_array = np.array([1, 5, 3, 9, 2])
max_value = np.max(my_array)
print(max_value)

# Output: 9

15. np.min(): Find the minimum value in an array.
    Syntax: np.min(array, axis=None, out=None, keepdims=False, initial=None)

# Example::
import numpy as np

# Find the minimum value in an array
my_array = np.array([1, 5, 3, 9, 2])
min_value = np.min(my_array)
print(min_value)

# Output: 1

16. np.mean(): Compute the arithmetic mean of an array.
    Syntax: np.mean(array, axis=None, dtype=None, out=None, keepdims=False)

# Example:
import numpy as np

# Compute the mean of an array
my_array = np.array([1, 2, 3, 4, 5])
mean_value = np.mean(my_array)
print(mean_value)

# Output: 3.0

17. np.median(): Compute the median of an array.
    Syntax: np.median(array, axis=None, out=None, overwrite_input=False)

# Example:
import numpy as np

# Compute the median of an array
my_array = np.array([1, 3, 2, 4, 5])
median_value = np.median(my_array)
print(median_value)

# Output: 3.0

18. np.std(): Compute the standard deviation of an array.
    Syntax: np.std(array, axis=None, dtype=None, out=None, ddof=0, keepdims=False)

# Example:
import numpy as np

# Compute the standard deviation of an array
my_array = np.array([1, 2, 3, 4, 5])
std_value = np.std(my_array)
print(std_value)

# Output: 1.4142135623730951

19. np.sum(): Compute the sum of array elements.
    Syntax: np.sum(array, axis=None, dtype=None, out=None, keepdims=False, initial=0)

# Example:
import numpy as np

# Compute the sum of array elements
my_array = np.array([1, 2, 3, 4, 5])
sum_value = np.sum(my_array)
print(sum_value)

# Output: 15

20. np.abs():Compute the absolute values of array elements.
    Syntax: np.abs(array)

# Example:
import numpy as np

# Compute the absolute values of array elements
my_array = np.array([-1, -2, 3, -4, 5])
abs_values = np.abs(my_array)
print(abs_values)

# Output: [1 2 3 4 5]

21. np.exp(): Compute the exponential of array elements.
    Syntax: np.exp(array)

# Example::
import numpy as np

# Compute the exponential of array elements
my_array = np.array([1, 2, 3])
exp_values = np.exp(my_array)
print(exp_values)

# Output: [ 2.71828183 7.3890561 20.08553692]

22. np.log(): Compute the natural logarithm of array elements.
    Syntax: np.log(array)

# Example:
import numpy as np

# Compute the natural logarithm of array elements
my_array = np.array([1, np.e, np.e**2])
log_values = np.log(my_array)
print(log_values) # Output: [0. 1. 2.]

23. np.sin(): Compute the sine of array elements.
    Syntax: np.sin(array)

# Example:
import numpy as np

# Compute the sine of array elements
my_array = np.array([0, np.pi/2, np.pi])
sin_values = np.sin(my_array)
print(sin_values)

# Output: [0.0000000e+00 1.0000000e+00 1.2246468e-16]

24. np.cos(): Compute the cosine of array elements.
    Syntax: np.cos(array)

# Example:
import numpy as np

# Compute the cosine of array elements
my_array = np.array([0, np.pi/2, np.pi])
cos_values = np.cos(my_array)
print(cos_values)

# Output: [ 1.000000e+00 6.123234e-17 -1.000000e+00]

25. np.tan(): Compute the tangent of array elements.
    Syntax: np.tan(array)

# Example:
import numpy as np

# Compute the tangent of array elements
my_array = np.array([0, np.pi/4, np.pi/2])
tan_values = np.tan(my_array)
print(tan_values)

# Output: [0.00000000e+00 1.00000000e+00 1.63312394e+16]

26. np.dot(): Compute the dot product of two arrays.
    Syntax: np.dot(a, b, out=None)

# Example:
import numpy as np

# Compute the dot product of two arrays
array1 = np.array([1, 2])
array2 = np.array([3, 4])
dot_product = np.dot(array1, array2)
print(dot_product)

# Output: 11

27. np.transpose(): Transpose the dimensions of an array.
    Syntax: np.transpose(array, axes=None)

# Example:
import numpy as np

# Transpose the dimensions of an array
my_array = np.array([[1, 2], [3, 4]])
transposed_array = np.transpose(my_array)
print(transposed_array)

# Output:
[[1 3]
[2 4]]

28. np.sort(): Sort an array.
    Syntax: np.sort(array, axis=-1, kind=None, order=None)

# Example:
import numpy as np

# Sort an array
my_array = np.array([3, 1, 4, 2, 5])
sorted_array = np.sort(my_array)
print(sorted_array)

# Output: [1 2 3 4 5]

29. np.unique(): Find the unique elements of an array.
    Syntax: np.unique(array, return_index=False, return_inverse=False, return_counts=False, axis=None)

# Example:
import numpy as np

# Find the unique elements of an array
my_array = np.array([1, 2, 1, 3, 2, 4])
unique_values = np.unique(my_array)
print(unique_values)

# Output: [1 2 3 4]

30. np.argmax(): Find the indices of the maximum values in an array.
    Syntax: np.argmax(array, axis=None, out=None)

# Example:
import numpy as np

# Find the indices of the maximum values in an array
my_array = np.array([3, 1, 4, 2, 5])
max_index = np.argmax(my_array)
print(max_index)

# Output: 4

31. np.argmin(): Find the indices of the minimum values in an array.
    Syntax: np.argmin(array, axis=None, out=None)

# Example:
import numpy as np

# Find the indices of the minimum values in an array
my_array = np.array([3, 1, 4, 2, 5])
min_index = np.argmin(my_array)
print(min_index)

# Output: 1

32. np.where(): Return the indices of array elements that satisfy a condition.
    Syntax: np.where(condition, x, y)

# Example:
import numpy as np

# Return the indices of array elements that satisfy a condition
my_array = np.array([1, 2, 3, 4, 5])
indices = np.where(my_array > 2)
print(indices)

# Output: (array([2, 3, 4]),)

33. np.any():Check if any element in an array satisfies a condition.
    Syntax: np.any(array, axis=None, out=None, keepdims=False)

# Example:
import numpy as np

# Check if any element in an array satisfies a condition
my_array = np.array([1, 2, 3, 4, 5])
has_positive = np.any(my_array > 0)
print(has_positive)

# Output: True

34. np.all(): Check if all elements in an array satisfy a condition.
    Syntax: np.all(array, axis=None, out=None, keepdims=False)

# Example:
import numpy as np

# Check if all elements in an array satisfy a condition
my_array = np.array([1, 2, 3, 4, 5])
all_positive = np.all(my_array > 0)
print(all_positive)

# Output: True

35. np.isnan(): Check for NaN (Not a Number) values in an array.
    Syntax: np.isnan(array)

# Example:
import numpy as np

# Check for NaN (Not a Number) values in an array
my_array = np.array([1, np.nan, 3, np.nan])
has_nan = np.isnan(my_array)
print(has_nan)

# Output: [False True False True]

36. np.logical_and(): Perform element-wise logical AND operation on arrays.
    Syntax: np.logical_and(array1, array2)

# Example:
import numpy as np

# Perform element-wise logical AND operation on arrays
array1 = np.array([True, False, True, False])
array2 = np.array([True, True, False, False])
result = np.logical_and(array1, array2)
print(result)

# Output: [ True False False False]

37. np.logical_or(): Perform element-wise logical OR operation on arrays.
    Syntax: np.logical_or(array1, array2)

# Example:
import numpy as np

# Perform element-wise logical OR operation on arrays
array1 = np.array([True, False, True, False])
array2 = np.array([True, True, False, False])
result = np.logical_or(array1, array2)
print(result)

# Output: [ True True True False]

38. np.logical_not(): Perform element-wise logical NOT operation on an array.
    Syntax: np.logical_not(array)

# Example:
import numpy as np

# Perform element-wise logical NOT operation on an array
my_array = np.array([True, False, True, False])
result = np.logical_not(my_array)
print(result)

# Output: [False True False True]

39. np.sinh(): Compute the hyperbolic sine of array elements.
    Syntax: np.sinh(array)

# Example:
import numpy as np

# Compute the hyperbolic sine of array elements
my_array = np.array([0, 1, 2])
sinh_values = np.sinh(my_array)
print(sinh_values)

# Output: [ 0. 1.17520119 3.62686041]

40. np.cosh(): Compute the hyperbolic cosine of array elements.
    Syntax: np.cosh(array)

# Example:
import numpy as np

# Compute the hyperbolic cosine of array elements
my_array = np.array([0, 1, 2])
cosh_values = np.cosh(my_array)
print(cosh_values)

# Output: [ 1. 1.54308063 3.76219569]

41. np.tanh(): Compute the hyperbolic tangent of array elements.
    Syntax: np.tanh(array)

# Example:
import numpy as np

# Compute the hyperbolic tangent of array elements
my_array = np.array([0, 1, 2])
tanh_values = np.tanh(my_array)
print(tanh_values)

# Output: [0. 0.76159416 0.96402758]

42. np.arcsin(): Compute the inverse sine of array elements.
    Syntax: np.arcsin(array)

# Example:
import numpy as np

# Compute the inverse sine of array elements
my_array = np.array([0, 0.5, 1])
arcsin_values = np.arcsin(my_array)
print(arcsin_values)

# Output: [0. 0.52359878 1.57079633]

43. np.arccos(): Compute the inverse cosine of array elements.
    Syntax: np.arccos(array)

# Example:
import numpy as np

# Compute the inverse cosine of array elements
my_array = np.array([0, 0.5, 1])
arccos_values = np.arccos(my_array)
print(arccos_values)

# Output: [1.57079633 1.04719755 0.]

44. np.arctan(): Compute the inverse tangent of array elements.
    Syntax: np.arctan(array)

# Example:
import numpy as np

# Compute the inverse tangent of array elements
my_array = np.array([0, 1, np.inf])
arctan_values = np.arctan(my_array)
print(arctan_values)

# Output: [0. 0.78539816 1.57079633]

45. np.pi: A constant representing the value of pi (π). A constant representing the value of pi (π)

# Example:
import numpy as np

# Use the constant pi
radius = 1.0
circumference = 2 * np.pi * radius
print(circumference)

# Output: 6.283185307179586

        46. np.e: A constant representing the value of Euler’s number (e). A constant representing the value of Euler’s number (e)

# Example::
import numpy as np

# Use the constant e
exponent = 1.0
result = np.exp(exponent)
print(result)

# Output: 2.718281828459045

47. np.log10(): Compute the base-10 logarithm of array elements.
    Syntax: np.log10(array)

# Example:
import numpy as np

# Compute the base-10 logarithm of array elements
my_array = np.array([1, 10, 100])
log10_values = np.log10(my_array)
print(log10_values)

# Output: [0. 1. 2.]

48. np.floor(): Round down array elements to the nearest integer.
    Syntax: np.floor(array)

# Example:
import numpy as np

# Round down array elements to the nearest integer
my_array = np.array([1.2, 2.7, 3.5])
floor_values = np.floor(my_array)
print(floor_values)

# Output: [1. 2. 3.]

49. np.ceil(): Round up array elements to the nearest integer.
    Syntax: np.ceil(array)

# Example:
import numpy as np

# Round up array elements to the nearest integer
my_array = np.array([1.2, 2.7, 3.5])
ceil_values = np.ceil(my_array)
print(ceil_values)

# Output: [2. 3. 4.]

50. np.isclose(): Check if two arrays are element-wise approximately equal.
    Syntax: np.isclose(a, b, rtol=1e-05, atol=1e-08, equal_nan=False)

# Example:
import numpy as np

# Check if two arrays are element-wise approximately equal
array1 = np.array([1.0, 2.0, 3.0])
array2 = np.array([1.1, 2.2, 3.3])
is_close = np.isclose(array1, array2, rtol=0.1, atol=0.1)
print(is_close)

# Output: [ True True True]

      51. np.correlate(): Compute the cross-correlation of two arrays.
Syntax: np.correlate(a, v, mode=’valid’)

# Example:
import numpy as np

# Compute the cross-correlation of two arrays
a = np.array([1, 2, 3, 4, 5])
v = np.array([0, 1, 0.5])
correlation = np.correlate(a, v, mode=’valid’)
print(correlation)

# Output: [4.5 6. 8.5]

52. np.cov(): Compute the covariance matrix of an array.
    Syntax: np.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None)

# Example:
import numpy as np

# Compute the covariance matrix of an array
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
cov_matrix = np.cov(data, rowvar=False)
print(cov_matrix)

# Output:
[[6. 6. 6.]
[6. 6. 6.]
[6. 6. 6.]]

• 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

Practice	Description
Use meaningful names	calculate_total() is better than ct()
Keep functions short	One task per function
Document your function	Write comments or use docstrings
Avoid global variables	Prefer passing parameters

---

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}