Question 1: Reverse Words in a String III

 

def reverseWords(s: str) -> str:
    words = s.split()
    return ' '.join(word[::-1] for word in words)

Network Programming

 Sockets

https://notes.shichao.io/unp/ch3/ 

Slideshare PPT

Socket Programming - Youtube

Socket Address

A socket is one endpoint of a two way communication link between two programs running on the network. The socket mechanism provides a means of inter-process communication (IPC) by establishing named contact points between which the communication take place. 

sockets is created using ‘socket’ system call. The socket provides bidirectional FIFO Communication facility over the network. A socket connecting to the network is created at each end of the communication. Each socket has a specific address. This address is composed of an IP address and a port number.

The server creates a socket, attaches it to a network port addresses then waits for the client to contact it. The client creates a socket and then attempts to connect to the server socket. When the connection is established, transfer of data takes place.

Types of Sockets : There are two types of Sockets: the datagram socket and the stream socket.

1. Datagram Socket : This is a type of network which has connection less point for sending and receiving packets. It is similar to mailbox. The letters (data) posted into the box are collected and delivered (transmitted) to a letterbox (receiving socket).

2. Stream Socket In Computer operating system, a stream socket is type of interprocess communications socket or network socket which provides a connection-oriented, sequenced, and unique flow of data without record boundaries with well defined mechanisms for creating and destroying connections and for detecting errors.

IPv4 Socket Address

An IPv4 socket address structure, commonly called an "Internet socket address structure," is

named sockaddr_in and is defined by including the <netinet/in.h> header.

The four socket functions that pass a socket address structure from the process to the kernel:

•  bind
•  connect
•  sendto
•  sendmsg

The five socket functions that pass a socket address structure from the kernel to the process:

•  accept
•  recvfrom
•  recvmsg
•  getpeername
•  getsockname

Sockets: A Comprehensive Overview

1. Socket Address Structures

• Purpose: To hold the address of a socket, including IP address and port number.
• Common Structures:
  • struct sockaddr_in: For IPv4 addresses.
  • struct sockaddr_in6: For IPv6 addresses.
  • struct sockaddr_un: For Unix domain sockets.
• Key Fields:
  • sin_family: Address family (AF_INET, AF_INET6, AF_UNIX).
  • sin_port: Port number in network byte order.
  • sin_addr: IP address in network byte order.
• Usage: These structures are used in various socket functions like bind, connect, and listen to specify the address of the socket.

2. Value-Result Arguments

• Concept: A type of argument passed to a function where the function modifies the argument's value and returns it to the caller.
• Socket Context: Socket address structures are often passed as value-result arguments. The function fills the structure with the appropriate information (e.g., remote address) and returns it to the caller.
• Example: The accept function takes a sockaddr structure as an argument. After accepting a connection, the function fills the structure with the address of the client and returns it to the caller.

3. Byte Ordering and Manipulation Functions

• Byte Order: Refers to the way bytes are arranged in memory.
  • Big-Endian: Most significant byte first.
  • Little-Endian: Least significant byte first.
• Manipulation Functions:
  • htons: Converts a 16-bit host value to network byte order.
  • htonl: Converts a 32-bit host value to network byte order.
  • ntohs: Converts a 16-bit network value to host byte order.
  • ntohl: Converts a 32-bit network value to host byte order.
• Purpose: These functions are essential for ensuring correct data transmission over the network, as different systems may have different byte orders.

4. Elementary TCP Sockets

• Socket Function: Creates a socket and returns a socket descriptor.
  • socket(domain, type, protocol)
• Connect Function: Connects a socket to a remote address.
  • connect(sockfd, addr, addrlen)
• Bind Function: Assigns a local address to a socket.
  • bind(sockfd, addr, addrlen)
• Listen Function: Puts a socket into listening mode.
  • listen(sockfd, backlog)
• Accept Function: Accepts a connection request from a client.
  • accept(sockfd, addr, addrlen)
• Fork Function: Creates a child process.
  • fork()
• Exec Function: Replaces the current process image with a new process image.
  • execve(pathname, argv, envp)
• Concurrent Servers: Servers that can handle multiple clients simultaneously, often achieved using the fork or select mechanisms.

5. Close Function and Related Functions

• Close Function: Closes a socket descriptor.
  • close(sockfd)
• Shutdown Function: Disables specific types of communication on a socket.
  • shutdown(sockfd, how)
• Purpose: These functions are crucial for proper resource management and graceful termination of network connections.

Deep Learning

 Introduction

Computer vision -  Overview

Biological neuron vs Neural Network - GFG

McCulloah pits Model - PPT

Perceptron Learning Algorithms - Web

Convergence theorem for Perceptron Learning Algorithm

Optimization basics - PPT

Neural Networks - 1

Feed Forward Neural Network - GFG

Multilayer Perceptron - MLP

Gradient descent

BackPropagation

Regularization - PPT, Youtube

Autoencoders - Youtube

Data Analysis Techniques

Classification

Classification is a Supervised Learning algorithm where the goal is to predict the category or class labelof given data points. It is used when the output variable is categorical .

How Classification Works?

1. Training Phase:

A model learns the relationship b/w the input features and their corresponding class labels from a labeled dataset.

2. Testing Phase:

The trained model is used to classify new, unseen data points into one of the predefined classes.

Types of Classification:

Binary Classification
Multi class classification
Multi label classification

Examples of Classification Tasks:

Email filtering
Medical diagnosis
Image recognition
sentiment Analysis

Classification Algorithms

Logistic Regression
Decision Trees
Support Vector Machines
K-Nearest Neighbours
Navie bayes
Random Forest

Evalution Metrics for Classification

Accuracy - Percentage of correctly labeled classes
Precision - How many +ve predictions are correct
Recall
F1 Score
ROC-AUC

Workflow of Classification

Data Collection: Gather labeled data.
Data Preprocessing: Clean, normalize, and split the data into training and testing sets.
Feature Selection: Identify the most relevant features.
Model Training: Train a classification model using a suitable algorithm.
Model Evaluation: Test the model on unseen data using evaluation metrics.
Prediction: Use the model for classifying new data.

Decision Tree Algorithm

A Decision Tree is a supervised machine learning algorithm used for classification and regression tasks. It models decisions and their possible consequences as a tree-like structure of nodes, where:

• Internal Nodes: Represent a decision based on a feature.
• Branches: Indicate the outcome of a decision.
• Leaf Nodes: Represent the final outcome (class label or prediction).

The tree splits the data into subsets based on the feature that provides the most information gain or least impurity at each step.

Concepts in Decision Trees

1. Root Node:
   The starting point of the tree, representing the entire dataset.

2. Splitting:
   Dividing data at a node into subsets based on a condition (e.g., feature > value).

3. Leaf Node:
   A terminal node that provides the final prediction.

4. Pruning:
   Reducing the size of the tree to avoid overfitting.

5. Impurity Measures (used for splitting):

   • Gini Impurity: Measures the likelihood of incorrect classification if a random sample is classified based on the distribution. $$Gini=1-\sum _{i=1}^n{p}_i^{\mathrm{2}}$$
   • Entropy: Measures the randomness or impurity of a dataset. $$Entropy=-\sum _{i=1}^n{p}_i{\log }_2(p_i)$$
   • Information Gain: The reduction in entropy or impurity achieved by a split. $$\text{Information Gain} = \text{Entropy(parent)} - \text{Weighted Entropy(children)}$$
     

Advantages of Decision Trees

1. Simple to Understand: Mimics human decision-making.
2. Interpretable: Provides clear visualization of the decision process.
3. Non-Parametric: No assumptions about data distribution.
4. Handles Non-linear Relationships: Can model complex patterns.

Disadvantages of Decision Trees

1. Overfitting: Trees can grow too large and fit the training data perfectly, leading to poor generalization.
2. Bias to Dominant Features: Sensitive to unbalanced datasets.
3. Instability: Small changes in data can result in significantly different trees.

How Decision Trees Work

1. Start at the Root Node: Evaluate all features and split the data based on the feature that provides the highest information gain or lowest Gini impurity.
2. Recursive Splitting: Continue splitting each subset at child nodes until:
   • All data points in a node belong to the same class.
   • A stopping criterion (e.g., maximum depth, minimum samples) is met.
3. Prediction: For a new data point, follow the path from the root node to a leaf node to determine the predicted class.

=======================================================================
Python Code

from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.tree import DecisionTreeClassifier, plot_tree

import matplotlib.pyplot as plt

# Load dataset

data = load_iris()

X = data.data  # Features

y = data.target  # Target labels

# Split data into training and testing sets

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Train a decision tree classifier

model = DecisionTreeClassifier(criterion='gini', max_depth=3, random_state=42)

model.fit(X_train, y_train)

# Visualize the decision tree

plt.figure(figsize=(12, 8))

plot_tree(model, feature_names=data.feature_names, class_names=data.target_names, filled=True)

plt.show()

# Evaluate the model

accuracy = model.score(X_test, y_test)

print(f"Accuracy: {accuracy:.2f}")

======================================================================

Bayes theorem

Bayes' Theorem is a fundamental concept in probability theory and statistics that describes the probability of an event, based on prior knowledge of conditions that might be related to the event. In machine learning, it is widely used for classification tasks, particularly in Naive Bayes classifiers.

---

Bayes' Theorem Formula

Bayes' Theorem is expressed mathematically as:

$$P(A\mathrm{\mid }B)=\frac{P(B\mathrm{\mid }A)\cdot P(A)}{P(B)}$$

Where:

• $P(A|B)$ is the posterior probability: The probability of event $A$ occurring given that $B$ has occurred.
• $P(B|A)$ is the likelihood: The probability of event $B$ occurring given that $A$ has occurred.
• $P(A)$ is the prior probability: The probability of event $A$ occurring before observing event $B$.
• $P(B)$ is the evidence or normalizing constant: The total probability of event $B$ occurring (the denominator ensures the total probability sums to 1).

---

Explanation of the Components

1. Prior Probability ($P(A)$): This represents what is known about $A$ before any new data is observed. It’s the initial belief or assumption about a class or event.

2. Likelihood ($P(B|A)$): This is the likelihood of observing the evidence $B$ given that $A$ is true. It quantifies how well the evidence supports the hypothesis.

3. Posterior Probability ($P(A|B)$): This is the probability of $A$ occurring after considering the evidence $B$. It's the updated belief after observing the data.

4. Evidence ($P(B)$): This is the total probability of observing $B$ across all possible outcomes. It is used to normalize the result to ensure the probabilities sum to 1.

---

Naive Bayes Classifier in Machine Learning

In machine learning, the Naive Bayes classifier is based on Bayes' Theorem, with the assumption that the features used for prediction are conditionally independent given the class label. This simplifies the calculation, hence the term "naive."

Steps for Naive Bayes Classification:

1. Compute the Prior Probability:
   The probability of each class occurring in the dataset.

   $$P(C_k) = \frac{\text{Number of instances of class } C_k}{\text{Total number of instances}}$$

2. Compute the Likelihood:
   Calculate the likelihood for each feature given the class label. For continuous features, this often assumes a Gaussian distribution.

   $$P(X_i | C_k) = \text{Likelihood of feature } X_i \text{ given class } C_k$$

3. Compute the Posterior Probability:
   For each class $C_k$, compute the posterior probability of a new data point $X = (X_1, X_2, ..., X_n)$:

   $$P(C_k | X) = \frac{P(C_k) \cdot \prod_{i=1}^{n} P(X_i | C_k)}{P(X)}$$

4. Classify the Data Point:
   Choose the class $C_k$ with the highest posterior probability as the predicted class.

==================================================================

Handling Class Imbalance in Support Vector Machines (SVM)

Class imbalance occurs when the number of samples in one class significantly exceeds those in another class. This can negatively impact the performance of Support Vector Machines (SVM), as the decision boundary may be biased towards the majority class, leading to poor performance on the minority class.

---

Challenges with Class Imbalance in SVM

1. Bias Toward Majority Class: The SVM objective function may focus more on maximizing the margin for the majority class, ignoring the minority class.
2. Skewed Decision Boundary: The decision boundary may shift closer to the minority class, reducing its classification performance.
3. Poor Evaluation Metrics: Standard metrics like accuracy may not reflect the true performance of the model on imbalanced datasets.

---

Techniques to Address Class Imbalance in SVM

1. Class Weight Adjustment:
   Assign higher weights to the minority class to balance the penalty during training.

   • In Scikit-learn, this can be done using the class_weight parameter:

     from sklearn.svm import SVC
     
     # Assign 'balanced' to automatically compute weights
     model = SVC(class_weight='balanced')
     

   • Or manually specify weights:

     model = SVC(class_weight={0: 1, 1: 10})  # Higher weight for class 1 (minority)
     

2. Resampling Techniques:

   • Oversampling: Increase the number of minority class samples by duplicating or generating synthetic samples (e.g., using SMOTE).
   • Undersampling: Reduce the number of majority class samples to match the minority class.

   Example using SMOTE:

   from imblearn.over_sampling import SMOTE
   from sklearn.svm import SVC
   from sklearn.model_selection import train_test_split
   
   # Create synthetic samples for the minority class
   smote = SMOTE(random_state=42)
   X_resampled, y_resampled = smote.fit_resample(X, y)
   
   # Train an SVM on the balanced dataset
   model = SVC()
   model.fit(X_resampled, y_resampled)
   

3. Change the Decision Threshold: Adjust the threshold for classifying a sample as a minority class based on the predicted probabilities.

   Example:

   from sklearn.svm import SVC
   from sklearn.metrics import classification_report
   
   # Fit SVM
   model = SVC(probability=True)
   model.fit(X_train, y_train)
   
   # Predict probabilities
   y_prob = model.predict_proba(X_test)[:, 1]
   
   # Adjust threshold
   threshold = 0.3
   y_pred = (y_prob >= threshold).astype(int)
   
   # Evaluate performance
   print(classification_report(y_test, y_pred))
   

4. Kernel Selection: Use kernels that better separate the minority and majority classes, such as the RBF kernel, which can handle non-linear boundaries.

5. Feature Engineering: Transform or create features that emphasize differences between the classes. This can improve separability in the feature space.

6. Use of Alternative Metrics: Evaluate the model using metrics like:

   • Precision, Recall, F1 Score
   • Area Under the Receiver Operating Characteristic Curve (AUC-ROC)
   • Precision-Recall Curve

========================================================================

Random Forest is a popular ensemble learning technique used for both classification and regression tasks. It combines the predictions of multiple decision trees to improve accuracy, reduce overfitting, and enhance generalization.

---

Key Features of Random Forest

1. Ensemble Method: It creates multiple decision trees during training and combines their results for better performance.
2. Bagging: It employs bootstrapping (sampling with replacement) to create different subsets of the training data for each tree.
3. Random Feature Selection: At each split in a tree, only a random subset of features is considered, making the model less prone to overfitting.
4. Majority Voting (Classification): For classification tasks, it uses the majority vote of the trees as the final prediction.
5. Averaging (Regression): For regression tasks, it uses the average of the predictions from all trees.

---

How Random Forest Works

1. Bootstrap Aggregation (Bagging):

   • Randomly sample the dataset with replacement to create multiple subsets of the data (one for each tree).
   • Train each decision tree on a different subset.

2. Feature Randomness:

   • At each split in a decision tree, a random subset of features is considered instead of evaluating all features.
   • This adds diversity to the trees and prevents overfitting.

3. Prediction Aggregation:

   • For classification: Take the majority vote across all decision trees.
   • For regression: Compute the average of the predictions.

---

Advantages of Random Forest

1. Robust to Overfitting: Combines multiple trees, reducing the risk of overfitting compared to individual decision trees.
2. Handles Non-linear Data: Captures complex relationships in data.
3. Works Well with Missing Values: Can handle datasets with missing values by averaging predictions.
4. Scales Well to Large Datasets: Performs efficiently with high-dimensional data.
5. Feature Importance: Provides insights into feature significance, aiding interpretability.

---

Disadvantages of Random Forest

1. Computationally Intensive: Training multiple decision trees can be slow, especially with large datasets.
2. Not as Interpretable: While decision trees are interpretable, combining them into a forest makes the model harder to understand.
3. Bias in Small Data: May struggle with small datasets if not tuned properly.
4. Memory Usage: Requires more memory as it stores multiple trees.

---

Random Forest Algorithm

1. Input: Dataset $D$ with $n$ samples, number of trees $T$, and number of features $m$ to select at each split.
2. For Each Tree:
   • Draw a bootstrap sample from $D$.
   • Build a decision tree on the bootstrap sample.
   • At each split, randomly select $m$ features and choose the best split among them.
3. Aggregate Predictions:
• For classification, use majority voting.
• For regression, compute the average

=======================================================================

What is box plot?

 BOX PLOT

A boxplot (or box-whisker plot) is a graphical representation of the distribution of the dataset.

Components:

Minimum(Q0): The smallest data point.
First Quartile(Q1): The median of the lower half of the dataset(25% Percentile)
Median(Q2): The middle value of the dataset(50% percentile)
Third Quartile(Q3)
Maximum(Q4):

Significance of Box Plots

• Spread: The width of the box and length of the whiskers show variability in the data.
• Outliers: Easily identify unusual data points.
• Symmetry: A symmetric box indicates a symmetric distribution, while an asymmetric box shows skewness.

What is Histogram?

 Histogram 

A Histogram is a graphical representation of the distribution of a dataset. It divides the range of data into bins(intervals) and displays how many points falls into each bin.

key components:

bins: The intervals in which the data range is divided.

frequency: count of data points in each bin.

Vizualization: Typically represented as a bar chart.

Python

import matplotlib.pyplot as plt                                                                                                
data = [1,2,3,4,5,6,7,8,....]                                                                                                       
plt.hist(data, bins = 5, color = 'blue', edgecolor = 'black')                                                      
plt.title()                                                                                                                                  
plt.xlabel()                                                                                                                              
plt.ylabel()                                                                                                                              
plt.show()                                                                                                                                

Explanation:

Output:

Types of Histograms

1. bell shaped histogram
2. bimodal histogram
3. skewed right histogram
4. skewed left histogram
5. uniform histogram

Significance of Histograms:

1. Understanding the data distribution

The shape of a histogram reveals the underlying distribution of data, which is essential for statistical analysis. Common distributions include:

Normal distribution
uniform distribution
Bimodal distribution

2. Identifying the Central tendency

3. Understanding the Variability

The width of the histogram (spread of bins) indicates variability or dispersion

4. Detecting Outliers

Resources:

1. https://www.cuemath.com/data/histograms/ 

Lexicographical Order

 What is Lexicographical Order?

Lexicographical Order is a way of arranging words or sequences in the same order as they would appear in a dictionary. In this ordering, the sequences are compared character by character, based on their alphabetical order (or numerical order for digits).

Key Points:

1. The comparison starts with the first character of each sequence.
2. If the first characters are the same, the comparison moves to the next character.
3. Shorter sequences come before longer ones if one is a prefix of the other.

---

Example 1: Words

Consider the words:
apple, banana, bat, batman.

• Compare the first letters: a comes before b, so apple comes first.
• Compare banana and bat:
• The first letters are the same (b), so compare the second letters (a).
• Since a in banana comes before a in bat, compare the third letters.
• n in banana comes before t in bat. So, banana comes before bat.
• bat and batman:
• bat is a prefix of batman, so bat comes first.

Final order:
apple, banana, bat, batman.

---

Example 2: Numbers as Strings

Consider the numbers as strings:
101, 11, 110, 2.

• 101 vs 11:
• Compare the first digits: 1 is equal.
• Compare the second digits: 0 in 101 comes before 1 in 11. So, 101 comes first.
• 11 vs 110:
• 11 is a prefix of 110, so 11 comes first.
• 110 vs 2:
• Compare the first digits: 1 in 110 comes before 2. So, 110 comes first.

Final order:
101, 11, 110, 2.

---

Application:

Lexicographical order is used in:

• Sorting algorithms.
• String manipulations.
• Searching in dictionaries and databases.

 

Python Tutorial Part-1

Introduction

Python is a general purpose high level language.

Python was developed by Gudio Van rossam in 1989 while working at National Research Institute in Netherlands.

But officially python was made available to public in 1991

Example to Print HelloWorld

To print sum of two numbers

The name Python was selected from a TV Show

“The complete Monty Python’s Circus” was broadcasted by BBC from 1969 to 1974.

Guido developed Python language by taking almost all Programming features from different languages.

·         Functional Programming from c.

·         OOPS from C++

·         Scripting Languages from perl and shellscript

·         Modular language features from Modular-3

 Where we can use python

For Developing desktop Applications

For Developing web Applications

For Developing database Applications

For Data Analysis

For Machine Learning

Features of Python

·         Simple and easy to learn

·         Open source

·         High level Programming Language

·         Platform Independent

·         Portability

·         Dynamically Types

·         Procedured Oriented and Object oriented

·         Interpreted

·         Extensible

·         Embeded

 

Limitations of Python

Performance wise is not up to the mark

It is not used to build Mobile Applications

 

Identifiers

A name in python program is called an identifier.

It can be class name or function name or variable name or module name

 

Rules to define Identifiers in Python

·         Allowed Characters – Alphabet symbols, digits, underscore.

·         Identifiers are case sensitive.

·         It should not start with a digit.

NOTE

·         If Identifier is start with Underscore(_) then it indicates it is Private.

·         If Identifier is start with __(2 underscores) indicating strongly private.

·         If the identifier starts and ends with two underscore symbols then the identifier is language defined special name, which is also known as magic words.

Reserve Words

In python some words are reserved to represent some meaning or functionality.

There are 33 reserved words in python

·         True, False, None

·         And, or, not, is

·         If, elseif, else

·         While, for, break, continue, return, in, yield

·         Try, except, finally, raise, assert

·         Import, from, as, class, def, pass, global, nonlocal, lambda, del, with

 

DataTypes

Datatype represents the type of data present inside a variable.

In python we are not required to specify the type exclicitly. Based on the value provided, the type will be assigned automatically.

Python contains the following inbuilt datatypes

·         Int

·         Float

·         Complex

·         Bool

·         Byte

·         Str

·         Bytearray

·         Range

·         List

·         Tuple

·         Set

·         Frozenset

·         Dict

·         None

 

Slicing Strings

[] operater is called Slice operator.

In python String index can be +ve or -ve

 

Note

In python, we can represent char values also by using str type and explicitly char type is not available.

 

Type casting

We can convert one type to another type. This conversion is called Type conversion.

Note

·         We can convert from any type to int type except complex type.

·         If we want to convert str type to int type, compulsory str should contain only integral value and should be specified in base 10.

All Fundamental data types are immutable. Once we create an object, we cannot perform any changes in that object. If we are trying to change then with those changes a new object will be created. This is called immutability.

 

List Data type

If we want to represent a group of values as a single entity where insertion order required to preserve and duplicates are allowed then we should go for list data type.

·         Insertion order is preserved.

·         Heterogeneous objects are allowed

·         Duplicates are allowed.

·         Growable in nature.

·         mutable

·         Values should be enclosed within square brackets.

List is growable in nature, based on our requirement we can increase or decrease the size.

Tuple data type

It is exactly same as list data type except that is immutable. We cannot change values.

Tuple elements can be represented in parenthesis.

Note

Tuple is read only version of list

 

Set data type

·         Insertion order is not preserved

·         Duplicates are not allowed

·         Heterogeneous objects are allowed

·         Index concept is not applicable

·         It is mutable collection

·         Growable in nature.

 

Frosenset datatype

·         It is exactly same as set except that is immutable.

·         Hence we cannot use add or remove functions.

 

Dict datatype

·         If we represent a group of values as key value pairs then we should go dict data type.

·         Duplicates keys are not allowed.

 

NOTE

Dict is mutable and the order won’t be preserved.

 

Escape characters

·         /n – new line

·         /t – Horizontal tab

·         /r – Carriage return

·         /b – backspace

·         /f – form feed

·         /v – vertical tab

Constants

·         Constants concept is not applicable in python

·         But it is convention to use uppercase characters if we don’t want to change value.

·         It is just convention but we can change value.

 

Arithmetic operators

2. relational Operators

3. bitwise operators

 

4. Assignment Operators

 

 

Special Operators

·         Identity operators

·         Membership operators

Identity Operators

·         We can use for addresses comparison

·         Operators are – is, is not

NOTE

We can use is operator for addresses comparision where as == operator for content comparision.

Membership operators

·         Used to check whether the given object present in the given collection.

·         Operators – in, not in

 

Operator Precedence

 

Mathematical Functions(math module)

Math is a module that contains several functions to perform mathematical operators

Input()

Input() function can be used to read data directly in our required format. We are not required to perform type casting.

How to read mulptiple values from the keyboard in a single line:

Write a program to read 3 float numbers and their sum

Eval()

Eval function take a string and evaluate the result.

 

NOTE

Eval() can evaluate the input to list, tuple, set, etc based on provided input.

 

Write a program to accept list from the keyboard

 

NOTE

There is no switch statement in python.

Write a program to find Biggest of given 3 numbers

 

To print the characters present in string index wise is

Loops with else block

·         Inside loop execution, if break statement not executed, then only else part will be executed.

·         Else means loop without break.

Pass statement

·         It is an empty statement

·         It is null statement

·         It wont do anything

·         It is like abstract method in java.

 

Del statement

We can delete variable by using del keyword.