M

ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
 us
Pl
s
om
At
ti
ul
M

Link: Github Code

M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
M
ul
ti
At
om
s
Pl
us
Python Programming (BCC302 / BCC402/
BCC302H / BCC402H)

Unit-2 ONE SHOT

Python Program Flow Control Conditional Blocks
PYQS + IMP QUESTIONS
Syllabus
gh
●

● Conditional Statements - if else

● Loops - For, While
● Pass, Continue and break - (2022-23)
● If-else and Loops Programs - PYQs
Decision Making :
● Decision-making is the anticipation of conditions occurring during the execution of a
program and specified actions taken according to the conditions.
Decision structures evaluate multiple expressions, which produce TRUE or FALSE as
● the outcome. You need to determine which action to take and which statements to
execute if the outcome is TRUE or FALSE otherwise.
Python programming language assumes any non-zero and non-null values as TRUE,
and any zero or null values as FALSE value.
●
Python programming language provides the following types of decision-making
statements.

if statements if...else statements nested if statements

An if statement consists of An if statement can be You can use one if or else
a boolean expression followed by an optional if statement inside another
followed by one or else statement, which if or else if statements..
executes when the boolean
more statements.
expression is FALSE.
Let’s Code Decision Making Statements
 A loop statement allows us to execute
a statement or group of statements
multiple times.

Loops in Python types of loops:

● While Loop
● For Loop
● Nested Loop
With the while loop we can execute a set of statements as long as a condition is true.
For Loop

For loop provides a mechanism to repeat a task until a particular condition is True. It
is usually known as a determinate or definite loop because the programmer knows
exactly how many times the loop will repeat. The for...in statement is a looping
statement used in Python to iterate over a sequence of objects.
For Loop and Range() Function

The range() function is a built-in function in Python that is used to iterate over a
sequence of numbers. The syntax of range() is range(beg, end, [step])
The range() produces a sequence of numbers starting with beg (inclusive) and ending
with one less than the number end. The step argument is option (that is why it is
placed in brackets). By default, every number in the range is incremented by 1 but we
can specify a different increment using step. It can be both negative and positive, but
not zero.
Nested Loops

● Python allows its users to have nested loops, that is, loops that can be placed
inside other loops. Although this feature will work with any loop like while loop
as well as for loop.
A for loop can be used to control the number of times a particular set of
● statements will be executed. Another outer loop could be used to control the
number of times that a whole loop is repeated.
Loops should be properly indented to identify
which statements are contained
● within each for statement.
Break Statement in Python
The break statement in Python is used to terminate the loop or statement in which it is
present.
Continue Statement in Python
Continue is also a loop control statement just like the break statement. continue
statement is opposite to that of the break statement, instead of terminating the loop, it
forces to execute the next iteration of the loop. As the name suggests the continue
statement forces the loop to continue or execute the next iteration.
Pass Statement in Python
As the name suggests pass statement simply does nothing. The pass statement in
Python is used when a statement is required syntactically but you do not want any
command or code to execute. It is like a null operation, as nothing will happen if it is
executed.
Thank You so much for watching

Subscribe For More Videos

Join Telegram Channel for Notes

Python Programming (BCC302 / BCC402/
BCC302H / BCC402H)
Python Complex data types
Unit-3 ONE SHOT

PYQS + IMP QUESTIONS

Multi Atoms Plus
Syllabus

● String and its Operations - 2021-22

● List and its Operations - 2022-23
● Tuple and Dictionary - 2021-22(2)
● Functions - 2022-23

Multi Atoms Plus

Introduction to Python Complex Data Types:

● Python offers various data types to store and manipulate data.

● Complex data types include strings, lists, tuples, and dictionaries.

● These data types serve different purposes and have unique characteristics.

Multi Atoms Plus

Python String:
Strings in Python are identified as a contiguous set of characters represented in the
quotation marks. Python allows either pair of single or double quotes.

Operations:
1. Concatenation: Concatenation involves combining two or more strings into a
single string.
2. Indexing: Indexing allows accessing individual characters within a string using
their positions (indices).

● Python uses zero-based indexing, where the first character is at index 0.

3. Length: The ‘len()’ function returns the length of a string, i.e., the number of
characters it contains.
Multi Atoms Plus
4. Case Conversion: String methods like upper(), lower(), capitalize(), and title() can
change the case of characters in a string.

5. String Splitting and Joining:

● The split() method splits a string into a list of substrings based on a delimiter.
● The join() method concatenates elements of a list into a single string with a
specified

Lets Code

Multi Atoms Plus

Multi Atoms Plus
String Slicing
● string slicing is a technique used to extract a portion of a string by specifying a
range of indices.
● Syntax : string[start:stop:step]

1. Basic
2. Omitting Start or End
3. Negative Indices
4. Step Parameter
5. Reversing a String

Multi Atoms Plus

Lists in Python - 2022-23
● Lists are ordered collections of items in Python.
● They are versatile and can contain elements of different data types, including
integers, floats, strings, and even other lists.

1. Appending Elements
2. Removing Elements
3. Slicing Lists
4. Concatenating Lists
5. Reversing a String
Multi Atoms Plus
2022-23- 2marks

Multi Atoms Plus

Lists Comprehension - 2022-23
Python also supports computed lists called list comprehensions having the following
syntax. List = [expression for variable in sequence]
Where, the expression is evaluated once, for every item in the sequence.

List comprehensions help programmers to create lists in a concise way. This is mainly
beneficial to make new lists where each element is the obtained by applying some
operations to each member of another sequence or iterable. List comprehension is also
used to create a subsequence of those elements that satisfy a certain condition.
Multi Atoms Plus
Tuples in Python
● Tuples are ordered collections of elements in Python.
● They are similar to lists but are immutable, meaning their elements cannot be
changed after creation.

1. Immutable Nature
2. Tuple Unpacking
3. Length and Membership Test
Multi Atoms Plus
Dictionaries in Python - 2022-23
● Dictionaries are unordered collections of key-value pairs in Python.
● They provide a flexible way to store and retrieve data, where each value is
associated with a unique key.

1. Adding Items
2. Removing Items
3. Dictionary Methods - keys() , values() , items().

Multi Atoms Plus

Multi Atoms Plus
Multi Atoms Plus
Functions
● Functions are reusable blocks of code that perform specific tasks.
● They help organize code into manageable chunks, promote code reuse, and
enhance readability.

Lets Code

Multi Atoms Plus

Multi Atoms Plus
Multi Atoms Plus
Multi Atoms Plus
Thank You so much for watching

Subscribe For More Videos

Join Telegram Channel for Notes

Multi Atoms Plus

 Multi Atoms Plus

Python Programming

Unit-4 One Shot (BCC-302 & BCC-402)

Python File Operations

 Multi Atoms Plus
Unit-4 Syllabus

Theory + Coding Part + Important Ques

 Multi Atoms Plus
Introduction to Python File Operations
File operations in Python allow you to perform various tasks on files such as reading,
writing, appending, and manipulating the file pointer. Python provides built-in
functions and methods to work with files efficiently.

File: A file is a digital container used to store data on a computer. It has a name, often
with an extension indicating its type (e.g., .txt for text files), and can contain various
types of information such as text, images, or programs. Files are essential for data
allowing information to be saved and retrieved later.

Types of files:

1. Text Files : .txt, .log etc.

2. Binary Files : .mp4, .mov, .png etc.
 Multi Atoms Plus
File operations in Python involve several key tasks. You can open a file in various
modes such as read ('r'), write ('w'), and append ('a'). Reading operations include
reading the entire file content at once, reading line by line, or reading all lines into a
list. Writing operations allow you to write a single string or multiple lines to a file.

Python can be used to perform operations on a file. (read & write data)

Open the File → Perform Operation → Close the File

open() read() or write() close()
 Multi Atoms Plus
File Opening in Python
File opening in Python involves using the open() function, which allows you to access
and interact with files.

file = open(filename, mode)

filename: Specifies the name of the file you want to open, including its path if it's not
in the current directory.
mode: Specifies the mode in which the file is opened.
# Opening a file in read mode
file = open('example.txt', 'r')
 Multi Atoms Plus
Different Modes
● 'r': Read mode. Opens a file for reading. (default mode)
● 'w': Write mode . Opens a file for writing. If the file exists, it truncates the file to
zero length. If the file does not exist, it creates a new file.
● 'a': Append mode. Opens a file for appending data. The file pointer is at the end
of the file if the file exists. If the file does not exist, it creates a new file for writing.
● 'b': Binary mode. This can be added to any of the above modes (e.g., 'rb', 'wb', 'ab')
to work with binary files.
● '+': Open a file for updating (reading and writing). (eg. r+, w+)
It's recommended to use the with statement when opening files. This ensures that the file is
properly closed after its suite finishes, even if an exception is raised.

with open('example.txt', 'r') as file:

 Multi Atoms Plus
Reading files in Python
It involves several methods to retrieve data stored in files. The main methods for
reading files are:
● read()
● readline()
● readlines()
Reading the Entire File: The read() method reads the entire content of the file at once
and returns it as a single string. This is useful for small files but can be inefficient for
large files as it loads all data into memory.
file = open('example.txt', 'r')
content = file.read()
print(content)
file.close()
 Multi Atoms Plus
Reading Line by Line: The readline() method reads one line at a time from the file.
This is useful for processing large files line by line, as it doesn't load the entire file into
memory at once.

file = open('example.txt', 'r')

line = file.readline()
print(line)
file.close()
.strip() removes the newline character
print(line.strip())
 Multi Atoms Plus
Reading All Lines: The readlines() method reads all lines of the file and returns them
as a list of strings, where each string is a line from the file. This method can be
convenient for iterating over lines but may be inefficient for very large files.
file = open('example.txt', 'r')
lines = file.readlines()
print(lines)
file.close()
o/p = ['fsfs\n', 'sfsfsfsf\n', 'sfsf']
.strip() removes the newline character
print(lines.strip())

Let’s Code..
 Multi Atoms Plus
Writing to files in Python
It is an essential operation for data storage, logging, configuration files, and more. Here
are the basic methods for writing to files, including writing a single string, writing
multiple lines, and appending to a file.

1. Writing a Single String

The write() method allows you to write a single string to a file. This is useful for simple
text output. If the file does not exist, it will be created. If it does exist, the file will be
truncated (emptied) before writing the new content.

file = open('example.txt', 'w')

file.write('Hello, World!\n')

file.close()
 Multi Atoms Plus
2. Writing Multiple Lines
The writelines() method allows you to write a list of strings to a file. Each string in the
list is written to the file sequentially. This method does not add new lines
automatically, so each string should end with a newline character if needed.

lines = ['First line\n', 'Second line\n', 'Third line\n']

file = open('example.txt', 'w')

file.writelines(lines)

file.close()
 Multi Atoms Plus
3. Appending to a File
To append data to an existing file without truncating it, you can open the file in
append mode ('a'). The new data will be added at the end of the file.

file = open('example.txt', 'a')

file.write('This line will be appended.\n')

file.close()

By using these methods, you can efficiently write data to files in Python, ensuring
proper file management and data persistence. Always remember to close the file after
writing to ensure that all data is flushed from the buffer and saved to the disk, and to
release system resources.

Let’s Code..
 Multi Atoms Plus
`r'' Open text file for reading. The stream is positioned at the beginning of the file.

`r+'' Open for reading + writing. The stream is positioned at the beginning of the file.

`w'' Truncate file to zero length or create text file for writing. The stream →beginning.

`w+'' Open for reading + writing. The file is created if it does not exist, otherwise it is
truncated. The stream → beginning of the file.

`a'' Open for writing. The file is created if it does not exist. The stream is positioned at
the end of the file. Subsequent writes to the file will always end up at the then current
end of file.

`a+'' Open for reading + writing. The file is created if it does not exist. The stream is
positioned at the end of the file.

Let’s Code..
 Multi Atoms Plus
Deleting the file in Python
To delete a file in Python, you can use the os.remove() function from the os module.
Here’s how you can delete a file:

import os
file_path = 'example.txt'
if os.path.exists(file_path):
os.remove(file_path)
print(f"{file_path} successfully deleted.")
else:
print(f"{file_path} does not exist.")
Let’s Code..
 Multi Atoms Plus
Q. WAPP to write the no. of letters and digits in the given input
String in a file object.
input_string = input("Enter a string: ") # Write counts to a file
letters_count = 0 file_path = 'letter_digit_counts.txt'
digits_count = 0 file = open(file_path, 'w')
file.write(f"Number of letters:
{letters_count}\n")
for char in input_string:
file.write(f"Number of digits: {digits_count}\n")
if char.isalpha():
file.close()
letters_count += 1
elif char.isdigit():
digits_count += 1
Let’s Code..
 Multi Atoms Plus
File Handler in Python
File Handler Basics:

● A file handler, or file object, is an interface to interact with files in Python

programs.
● It is created when a file is opened using the open() function.

Operations:

● Reading: Use methods like read(), readline(), or iterate over lines with a loop.
● Writing: Employ write() to add content to a file, or writelines() to write multiple
lines at once.
● Moving the Pointer: Adjust the file pointer with seek() to navigate through the
file.
● Querying Position: Determine the current position with tell().
 Multi Atoms Plus
Modes: as previous

Closing Files:

● Call close() on the file handler to free up resources once operations are done.

Error Handling:

● Handle potential errors like FileNotFoundError or IOError when opening or

manipulating files.

Best Practices:

● Always close files after use to prevent resource leaks.

● Utilize context managers (with statement) for cleaner and safer file handling.
● Handle exceptions to gracefully manage file-related errors.
 Multi Atoms Plus
seek() Function in Python
It is used to change the current position (or offset) of the file pointer within a file. This
function is particularly useful when you need to navigate to a specific location in a file
to read or write data.

file_object.seek(offset, whence)
offset: It specifies the number of bytes to move the file pointer.

whence: It specifies the reference point from where the offset is calculated. It can take
one of the following values:

● 0 (default): Start of the file

● 1: Current position of the file pointer
● 2: End of the file
 Multi Atoms Plus
Moving the File Pointer:

● When you open a file, the file pointer starts at the beginning (0 offset).
● seek(offset, 0) moves the pointer offset bytes from the beginning of the file.
● seek(offset, 1) moves the pointer offset bytes from the current position.
● seek(offset, 2) moves the pointer offset bytes from the end of the file (a negative
offset is usually used in this case).
# Open a file Multi Atoms Plus
file = open('example.txt', 'r')
# Move pointer to the 10th byte from the start
file.seek(10, 0)
print(file.read(5)) # Reads 5 bytes from the current position (10th byte)
# Move 5 bytes forward from the current position
file.seek(5, 1)
print(file.read(10)) # Reads 10 bytes from the current position (15th byte)
# Move to the 10 bytes before the end of the file
file.seek(-10, 2)
print(file.read(5)) # Reads 5 bytes from this position (10 bytes before the end)
# Close the file
file.close()
 Multi Atoms Plus
tell() function in Python
The tell() function returns an integer that represents the current position of the file
pointer in bytes from the beginning of the file.’

file_object.tell()

Understanding and utilizing tell() allows precise control over file operations,
especially when dealing with large files or when needing to track and manage
file positions dynamically during file processing in Python.

Let’s Code..
 Multi Atoms Plus

Thanks for Watching

Please Subscribe and Share Multi Atoms Plus
Join Telegram for Notes
 Python Programming
Unit-5 One Shot
(BCC302 / BCC402/ BCC302H / BCC402H)
Python Packages

Multi Atoms Plus

Unit-5 Aktu Updated Syllabus

Multi Atoms Plus

Python Packages
A Python package is a collection of modules bundled together. These modules can
include functions, classes, and variables that can be used in your Python programs.
Packages help to organize and structure code, making it more modular, reusable, and
maintainable.

Key Concepts:
1. Module: A single file containing Python code (functions, classes, variables, etc.)
with a .py extension.
2. Package: A directory containing multiple modules and an __init__.py file, which
makes it a package. The __init__.py file can be empty or execute initialization code
for the package.

Multi Atoms Plus

Creating a Package
1. Directory Structure:

2. module1.py:

3. module2.py:

Multi Atoms Plus

4. __init__.py:

Using the Package

Multi Atoms Plus

Benefits of Using Packages
1. Modularity: Break down large programs into smaller, manageable, and reusable
modules.
2. Namespace Management: Avoid name conflicts by organizing code into separate
namespaces.
3. Reusability: Easily reuse code across different projects.
4. Maintainability: Easier to manage and maintain code.

Multi Atoms Plus

Popular Python Packages
Matplotlib: For creating static, animated, and interactive visualizations.

Numpy: For numerical computations and operations on large arrays and matrices.

Pandas: For data manipulation and analysis.

Requests: For making HTTP requests.

Installing Packages
Use pip, the Python package installer, to install packages from the Python Package
Index (PyPI).

Multi Atoms Plus

Introduction to Matplotlib
Matplotlib is a comprehensive library for creating static, animated, and interactive
visualizations in Python. It is widely used for data visualization in scientific computing,
data science, and machine learning.

Installation

Multi Atoms Plus

Types of Matplotlib
1. Line Plot - Displays data trends over time.
2. Scatter Plot - Shows relationships between variables.
3. Bar Chart - Compares categorical data values.
4. Histogram - Represents data distribution frequencies.
5. Pie Chart - Illustrates proportions of a whole.
6. Box Plot - Summarizes data distribution quartiles.
7. Violin Plot - Displays data distribution and density.
8. Heatmap - Visualizes matrix-like data with color.
9. Area Plot - Fills the area under a curve.
10. 3D Plot - Represents three-dimensional data visually.
11. Subplots - Multiple plots in one figure.
Multi Atoms Plus
Matplotlib Pyplot
Most of the Matplotlib utilities lies under the pyplot submodule, and are usually
imported under the plt alias: import matplotlib.pyplot as plt
Now the Pyplot package can be referred to as plt.
import matplotlib.pyplot as plt
import numpy as np
xpoints = np.array([0, 6])
ypoints = np.array([0, 250])
plt.plot(xpoints, ypoints)
plt.show()

Multi Atoms Plus

Line plot with Matplotlib:
A line plot in Matplotlib is used to display data points connected by straight lines. It's
particularly useful for showing trends over time or continuous data.

Multi Atoms Plus

Customizations
Line Color:

Use color names (e.g., 'blue'), hex codes (e.g., '#FF5733'), or RGB tuples (e.g., (0.1, 0.2,
0.5)).

Markers:

Types include '.' (point), 'o' (circle), 's' (square), '^' (triangle), etc.

Multi Atoms Plus

Bar plot with Matplotlib
A bar plot (or bar chart) in Matplotlib is used to display categorical data with
rectangular bars. Each bar's length represents the value of the category it represents.

Multi Atoms Plus

Horizontal Bar Plot:

Multi Atoms Plus

Scatter plot with Matplotlib
A scatter plot in Matplotlib is used to display the relationship between two variables by
plotting data points on a Cartesian plane. Each point represents a pair of values from
two datasets.

Multi Atoms Plus

pie chart with Matplotlib:
A pie chart in Matplotlib is used to display data as slices of a circle, representing
proportions of a whole. Each slice corresponds to a category and its size represents the
proportion of that category relative to the total.

Multi Atoms Plus

area plot in Matplotlib
An area plot in Matplotlib is used to display data where the area under a line is filled
in, making it easy to visualize cumulative totals or the relative size of different
categories over time.

Multi Atoms Plus

NumPy
NumPy is a fundamental library for numerical computing in Python. It provides
support for arrays, matrices, and a wide range of mathematical functions to operate on
these data structures.

Key Features of NumPy

N-dimensional Arrays:
numpy.array(): Creates arrays for efficient storage and manipulation of numerical data.
Mathematical Functions:
Functions for mathematical operations, including addition, subtraction, multiplication, and
complex functions like trigonometric functions.
Array Operations:
Operations like element-wise addition, multiplication, and other mathematical operations on
arrays.
Multi Atoms Plus
Linear Algebra:

Functions for linear algebra operations such as dot products, matrix multiplication,
and eigenvalue decomposition.

Random Number Generation:

Functions to generate random numbers and distributions.

Array Manipulation:

Functions for reshaping, slicing, and aggregating data.

Multi Atoms Plus

Example Output

Multi Atoms Plus

Pandas
Pandas is a powerful data manipulation and analysis library for Python. It provides data
structures like DataFrames and Series that make it easy to handle and analyze large
datasets. Pandas is especially useful for working with tabular data and provides a
variety of functions to clean, transform, and analyze data.

Core Features of Pandas

Data Structures:

Series: A one-dimensional labeled array that can hold any data type.

DataFrame: A two-dimensional labeled data structure with columns of potentially different data
types.
Multi Atoms Plus
Creating Data Structures
# Creating a Series
s = pd.Series([1, 2, 3, 4, 5], name='numbers')
print(s)
# Creating a DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': ['a', 'b', 'c'],
'C': [4.5, 5.5, 6.5]
})
print(df) Multi Atoms Plus
Data Manipulation:

Indexing and Selection: Accessing and manipulating data using labels and
integer-based indexing.

1. Indexing and Selection using Labels (loc): Accessing data using labels.

Multi Atoms Plus

Multi Atoms Plus
Filtering: Methods for filtering

Multi Atoms Plus

Data Cleaning:

Handling Missing Data: Functions for detecting, filling, and dropping missing values.

Data Transformation: Tools for reshaping and transforming data.

Multi Atoms Plus

Multi Atoms Plus
Data Input/Output:

Reading/Writing Data: Functions for reading from and writing to various file formats including CSV, Excel

1. Reading CSV Files: Using pd.read_csv() to read data from a CSV file.

2. Reading Excel Files: Using pd.read_excel() to read data from an Excel file.

Multi Atoms Plus

The to_csv('output.csv', index=False) function writes the DataFrame df to the
CSV file output.csv. The index=False parameter ensures that the row indices
are not written to the file.

Multi Atoms Plus

What is a GUI in Python?
A Graphical User Interface (GUI) in Python is a visual interface that allows users to
interact with the application through graphical elements like windows, buttons, text
fields, and other widgets, rather than using text-based commands. GUIs make
applications user-friendly and visually appealing.

Python offers several libraries to create GUIs, with Tkinter being the most commonly
used due to its simplicity and integration with Python's standard library. Other popular
GUI frameworks include PyQt, Kivy, and wxPython.

Multi Atoms Plus

Multi Atoms Plus
Explanation
1. Import the Tkinter module:
This imports the Tkinter module and makes it available
in the script.
2. Define the function to update the label:
This function retrieves the text from the entry widget
and updates the label widget with a greeting.
3. Create the main window:
● tk.Tk() creates the main window.
● root.title("Simple GUI Example") sets the title of
the window.
● root.geometry("300x200") sets the size of the
window.

Multi Atoms Plus

4. Create and pack the label widget:
● tk.Label(root, text="Enter your name:") creates a
label widget with the specified text.
● label.pack(pady=10) adds the label to the window
with some padding.
5. Create and pack the entry widget:
● tk.Entry(root) creates an entry widget for text
input.
● entry.pack(pady=5) adds the entry widget to the
window with some padding.
6. Create and pack the button widget:
● tk.Button(root, text="Submit",
command=update_label) creates a button widget
that calls the update_label function when clicked.

● button.pack(pady=10) adds the button to the

window with some padding.

Multi Atoms Plus

7. Run the main event loop:

This starts the Tkinter event loop, which waits

for user interactions and updates the GUI
accordingly.

Multi Atoms Plus

Common Tkinter Widgets with Examples and Definitions
Tkinter provides a variety of widgets to create interactive GUI applications. Here are
some of the common Tkinter widgets along with their definitions and examples:

1. Button: A Button widget is used to display a clickable button that can trigger a
function or event when clicked.

● tk.Button(root, text="Click Me", command=on_button_click): Creates a button with the

text "Click Me" that calls the on_button_click function when clicked.
● button.pack(): Adds the button to the window.

Multi Atoms Plus

2. Label: A Label widget is used to display text or images on the screen.

● tk.Label(root, text="This is a label"): Creates a label with the text "This is a label".
● label.pack(): Adds the label to the window.

Multi Atoms Plus

3. Entry: An Entry widget is used to create a single-line text input field.

● tk.Entry(root): Creates a single-line text input field.

● entry.pack(): Adds the entry field to the window.

Multi Atoms Plus

4. Text: A Text widget is used to create a multi-line text input field.

● tk.Text(root): Creates a multi-line text input field.

● text.pack(): Adds the text field to the window.

Multi Atoms Plus

5. Checkbutton (Checkbox): A Checkbutton widget is used to create a checkbox
that can be toggled on or off.

● checkbox_var = tk.IntVar(): Creates an integer variable to hold the state of the

checkbox (1 for checked, 0 for unchecked).
● tk.Checkbutton(root, text="Check me", variable=checkbox_var): Creates a
checkbox with the text "Check me" linked to the checkbox_var variable.
● checkbox.pack(): Adds the checkbox to the window.

Multi Atoms Plus

 Simple Calculator Using Tkinter
import tkinter as tk
add_button = tk.Button(root, text="Add", command=add)
def add(): add_button.pack()
result.set(float(entry1.get()) + float(entry2.get()))
subtract_button = tk.Button(root, text="Subtract",
def subtract(): command=subtract)
result.set(float(entry1.get()) - float(entry2.get())) subtract_button.pack()

def multiply(): multiply_button = tk.Button(root, text="Multiply",

result.set(float(entry1.get()) * float(entry2.get())) command=multiply)
multiply_button.pack()
def divide():
result.set(float(entry1.get()) / float(entry2.get())) divide_button = tk.Button(root, text="Divide",
command=divide)
root = tk.Tk() divide_button.pack()
root.title("Simple Calculator")
root.mainloop()
entry1 = tk.Entry(root)
entry1.pack()

entry2 = tk.Entry(root)
entry2.pack()

result = tk.DoubleVar()
result_label = tk.Label(root, textvariable=result)
result_label.pack()
Multi Atoms Plus
1. Import Tkinter Module:

2. Define Functions:

This function retrieves the values from entry1 and entry2, adds
them, and sets the result in the result variable.

Multi Atoms Plus

3. Create Main Window:

This creates the main window of the application and sets its title to "Simple Calculator".

4. Create Entry Widgets:

Creates the second entry widget for user input and adds it to the window.

5. Create Variable for Result:

This creates a Tkinter DoubleVar to hold the result of the calculations.

6. Create Result Label:

This creates a label that displays the result of the calculation. The label's text is bound to the result variable.

Multi Atoms Plus

7. Create Buttons:

8. Run the Main Event Loop:

This starts the Tkinter event loop, which waits for user interactions and updates the GUI accordingly.

Multi Atoms Plus

Python Programming with IDE (Integrated Development Environment)
An Integrated Development Environment (IDE) is a software application that provides
comprehensive facilities to computer programmers for software development. An IDE typically
includes a source code editor, build automation tools, and a debugger. Here are some popular
IDEs for Python programming and their key features:

1. PyCharm: Developed by JetBrains, PyCharm is a powerful and widely-used IDE for Python. It
comes in two versions: Community (free) and Professional (paid).

● Intelligent Code Editor: Code completion, real-time error checking, and quick fixes.
● Debugging and Testing: Integrated debugger and test runner.
● Version Control: Supports Git, SVN and more.
● Web Development: Supports Django, Flask, and other web frameworks.

Multi Atoms Plus

2. Visual Studio Code (VS Code): A lightweight, open-source code editor developed by
Microsoft, with extensive Python support through extensions.

● Extensible: Rich ecosystem of extensions, including Python support.

● Debugging: Built-in debugger.
● Integrated Terminal: Access to the terminal within the editor.
● Version Control: Built-in Git support.

3. Spyder: An open-source IDE specifically designed for scientific computing and data analysis,
often used with Anaconda distribution.

● Integrated IPython Console: Enhanced interactive Python shell.

● Editor: Syntax highlighting, code completion, and introspection.
● Documentation Viewer: Built-in help system.
● Plotting: Inline plotting with Matplotlib support.

Multi Atoms Plus

2. Visual Studio Code (VS Code): A lightweight, open-source code editor developed by
Microsoft, with extensive Python support through extensions.

● Extensible: Rich ecosystem of extensions, including Python support.

● Debugging: Built-in debugger.
● Integrated Terminal: Access to the terminal within the editor.
● Version Control: Built-in Git support.

3. Spyder: An open-source IDE specifically designed for scientific computing and data analysis,
often used with Anaconda distribution.

● Integrated IPython Console: Enhanced interactive Python shell.

● Editor: Syntax highlighting, code completion, and introspection.
● Documentation Viewer: Built-in help system.
● Plotting: Inline plotting with Matplotlib support.

Multi Atoms Plus

IDEs that support Python development
● PyCharm ● Eric Python IDE
● Visual Studio Code ● Rodeo
● Spyder ● Anaconda Navigator
● Jupyter Notebook ● IDLE
● Atom ● Geany
● Sublime Text ● NetBeans with Python Plugin
● Eclipse with PyDev ● Pyzo
● Thonny ● Bluefish
● Wing IDE ● Emacs with Python Mode
● Komodo IDE ● IntelliJ IDEA with Python Plugin

Multi Atoms Plus

Thank You
Please Subscribe Multi Atoms & Multi Atoms Plus
Join Telegram Channel for Notes
All the Best for your Exams

Multi Atoms Plus