UNIT-5

14 MARKS:
1.Ellaborate SQL Libraries in other databases with example.
SQL Libraries in Other Databases with Examples

SQL libraries in Python allow you to connect, interact with, and manage different types of databases.
These libraries provide an interface for executing SQL queries, fetching results, handling database
connections, and performing other database-related operations. Although the most common SQL
library in Python is sqlite3 (for SQLite databases), Python supports a variety of SQL databases,
including MySQL, PostgreSQL, Oracle, SQL Server, and others, each with its own corresponding
library.

Here’s an overview of some of the widely used libraries for connecting to SQL databases, along with
examples of how to use them:

1. SQLite: sqlite3

SQLite is a self-contained, serverless, and zero-configuration database engine. It is embedded directly

into the application and is commonly used for small to medium-sized applications. Python’s standard
library includes the sqlite3 module for interacting with SQLite databases.

Example: Using sqlite3 to interact with an SQLite database

import sqlite3

# Connect to the SQLite database (or create it if it doesn't exist)

conn = sqlite3.connect('example.db')

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute('''CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT, age
INTEGER)''')

# Insert data into the table

cursor.execute("INSERT INTO users (name, age) VALUES ('Alice', 30)")

cursor.execute("INSERT INTO users (name, age) VALUES ('Bob', 25)")

# Commit the transaction

conn.commit()

# Query data

cursor.execute("SELECT * FROM users")

rows = cursor.fetchall()

for row in rows:

print(row)

# Close the connection

conn.close()

Common Operations:

• connect(database): Connect to an SQLite database or create a new one.

• cursor.execute(sql_query): Executes an SQL query.

• fetchall(): Fetch all rows from the result of the query.

• commit(): Commit any changes (inserts, updates, deletes).

• close(): Close the database connection.

2. MySQL: mysql-connector-python

MySQL is a widely used open-source relational database management system. The mysql-connector-
python library is used to interact with MySQL databases in Python.

Installation:

pip install mysql-connector-python

Example: Using mysql-connector-python to interact with a MySQL database

import mysql.connector

# Connect to MySQL database

conn = mysql.connector.connect(

host='localhost', # MySQL server address

user='root', # MySQL username

password='password', # MySQL password

database='test_db' # Database to connect to

)

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute("CREATE TABLE IF NOT EXISTS users (id INT AUTO_INCREMENT PRIMARY KEY, name
VARCHAR(100), age INT)")

# Insert data into the table

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Alice", 30))

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Bob", 25))

# Commit the transaction

conn.commit()

# Query data

cursor.execute("SELECT * FROM users")

for row in cursor.fetchall():

print(row)

# Close the connection

conn.close()

Common Operations:

• connect(host, user, password, database): Connect to a MySQL database.

• cursor.execute(sql_query, params): Execute SQL queries (parameterized queries supported).

• commit(): Commit changes to the database.

• fetchall(): Fetch all results from the query.

• close(): Close the connection.

3. PostgreSQL: psycopg2

PostgreSQL is an advanced open-source relational database system. The psycopg2 library is the most
popular PostgreSQL database adapter for Python.

Installation:

pip install psycopg2

Example: Using psycopg2 to interact with a PostgreSQL database

import psycopg2

# Connect to PostgreSQL database

conn = psycopg2.connect(

dbname="test_db", # Database name

user="postgres", # PostgreSQL username

password="password", # PostgreSQL password

host="localhost" # PostgreSQL server address

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute("CREATE TABLE IF NOT EXISTS users (id SERIAL PRIMARY KEY, name VARCHAR(100),
age INT)")

# Insert data into the table

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Alice", 30))

cursor.execute("INSERT INTO users (name, age) VALUES (%s, %s)", ("Bob", 25))

# Commit the transaction

conn.commit()

# Query data

cursor.execute("SELECT * FROM users")

for row in cursor.fetchall():

print(row)

# Close the connection

conn.close()

Common Operations:

• connect(dbname, user, password, host): Connect to a PostgreSQL database.

• cursor.execute(sql_query, params): Execute SQL queries.

• commit(): Commit changes to the database.

• fetchall(): Fetch all results from the query.

• close(): Close the connection.

4. Oracle: cx_Oracle

Oracle Database is a multi-model database management system. The cx_Oracle library is used to
connect to Oracle databases from Python.

Installation:

pip install cx_Oracle

Example: Using cx_Oracle to interact with an Oracle database

import cx_Oracle

# Connect to Oracle database

conn = cx_Oracle.connect(

user="username", # Oracle username

password="password", # Oracle password

dsn="localhost:1521/xe" # Oracle DSN (hostname:port/service_name)

# Create a cursor object

cursor = conn.cursor()

# Create a table
cursor.execute('''

CREATE TABLE users (

id NUMBER PRIMARY KEY,

name VARCHAR2(100),

age NUMBER

''')

# Insert data into the table

cursor.execute("INSERT INTO users (id, name, age) VALUES (1, 'Alice', 30)")

cursor.execute("INSERT INTO users (id, name, age) VALUES (2, 'Bob', 25)")

# Commit the transaction

conn.commit()

# Query data

cursor.execute("SELECT * FROM users")

for row in cursor.fetchall():

print(row)

# Close the connection

conn.close()

Common Operations:

• connect(user, password, dsn): Connect to an Oracle database.

• cursor.execute(sql_query): Execute SQL queries.

• commit(): Commit changes to the database.

• fetchall(): Fetch all results from the query.

• close(): Close the connection.

5. SQL Server: pyodbc

SQL Server is a relational database management system from Microsoft. The pyodbc library is
commonly used to connect to SQL Server databases from Python.

Installation:

pip install pyodbc

Example: Using pyodbc to interact with a SQL Server database

import pyodbc

# Connect to SQL Server database

conn = pyodbc.connect(

'DRIVER={ODBC Driver 17 for SQL Server};'

'SERVER=localhost;'

'DATABASE=test_db;'

'UID=sa;'

'PWD=password'

# Create a cursor object

cursor = conn.cursor()

# Create a table

cursor.execute('''

CREATE TABLE users (

id INT PRIMARY KEY,

name VARCHAR(100),

age INT

''')

# Insert data into the table

cursor.execute("INSERT INTO users (id, name, age) VALUES (1, 'Alice', 30)")

cursor.execute("INSERT INTO users (id, name, age) VALUES (2, 'Bob', 25)")
# Commit the transaction

conn.commit()

# Query data

cursor.execute("SELECT * FROM users")

for row in cursor.fetchall():

print(row)

# Close the connection

conn.close()

Common Operations:

• connect(connection_string): Connect to a SQL Server database.

• cursor.execute(sql_query): Execute SQL queries.

• commit(): Commit changes to the database.

• fetchall(): Fetch all results from the query.

• close(): Close the connection.

2.Discuss in detail about GUI programming with example.
GUI Programming in Python

Graphical User Interface (GUI) programming allows developers to create interactive programs with
graphical elements such as buttons, text boxes, and images. In Python, there are several libraries for
creating GUIs, with Tkinter, PyQt, and Kivy being some of the most popular.

In this discussion, we'll focus on Tkinter, which is the standard library for GUI programming in
Python. It is widely used due to its simplicity and the fact that it comes pre-installed with Python,
making it very accessible for beginners.

1. Tkinter Overview

Tkinter is the Python interface to the Tk GUI toolkit. Tk was developed as a GUI library for the Tcl
programming language and later became the standard for many different programming languages,
including Python. Tkinter allows you to create windows, dialogs, and widgets such as buttons, labels,
entry fields, and menus, all with ease.

Key components of a Tkinter program include:

• Widgets: Elements like buttons, labels, text boxes, and entry fields.

• Geometry Management: Controls how widgets are arranged in the window (e.g., pack, grid,
or place).

• Event Handling: Binds events such as mouse clicks, key presses, etc., to functions.

2. Tkinter Basics

To use Tkinter, you need to import it into your Python program. Below is an example that creates a
simple window with a button.

Example 1: Basic Tkinter Program

import tkinter as tk

# Function to execute when button is clicked

def on_button_click():

label.config(text="Hello, Tkinter!")

# Create the main window

root = tk.Tk()

root.title("Simple Tkinter GUI")

root.geometry("300x200")

# Create a label widget

label = tk.Label(root, text="Welcome to Tkinter", font=("Arial", 14))

label.pack(pady=20)

# Create a button widget

button = tk.Button(root, text="Click Me", command=on_button_click)

button.pack(pady=10)

# Start the Tkinter event loop

root.mainloop()

Explanation:

1. tk.Tk(): Creates the main window.

2. root.title(): Sets the title of the window.

3. root.geometry(): Sets the window size.

4. tk.Label(): Creates a label widget with a specified text and font.

5. tk.Button(): Creates a button widget, and the command argument is used to link the button
to a function (on_button_click).

6. pack(): Places the widget in the window using the pack geometry manager.

7. root.mainloop(): Starts the Tkinter event loop, which keeps the window running.

When you run the program, you will see a window with a label and a button. When you click the
button, the text in the label changes.

3. Geometry Management in Tkinter

In Tkinter, there are three main ways to manage the layout of widgets in a window:

• pack(): Organizes widgets in a block (vertical or horizontal).

• grid(): Organizes widgets in a table-like structure.

• place(): Places widgets at a specific location in the window.

Example 2: Using grid() Geometry Manager

import tkinter as tk
def on_button_click():

label.config(text="You clicked the button!")

# Create main window

root = tk.Tk()

root.title("Grid Layout Example")

# Create widgets

label = tk.Label(root, text="Click the button", font=("Arial", 14))

button = tk.Button(root, text="Click Me", command=on_button_click)

# Grid layout

label.grid(row=0, column=0, padx=10, pady=10)

button.grid(row=1, column=0, padx=10, pady=10)

# Start the Tkinter event loop

root.mainloop()

Explanation:

• grid(row, column): Positions the widgets in a grid layout, with the specified row and column.

• padx and pady: Add padding around the widget for better spacing.

In this example, the label and button are arranged in a simple grid layout.

4. Event Handling in Tkinter

Event handling in Tkinter is done using event bindings. You can bind functions to different events like
mouse clicks, key presses, and window resizing.

Example 3: Handling Key Press and Mouse Click Events

import tkinter as tk

def on_key_press(event):

label.config(text=f"You pressed: {event.char}")

def on_click(event):

label.config(text=f"You clicked at ({event.x}, {event.y})")

# Create main window

root = tk.Tk()

root.title("Event Handling Example")

# Create a label

label = tk.Label(root, text="Press a key or click the mouse.", font=("Arial", 14))

label.pack(pady=20)

# Bind events

root.bind("<Key>", on_key_press) # Key press event

root.bind("<Button-1>", on_click) # Left mouse button click

# Start the Tkinter event loop

root.mainloop()

Explanation:

• bind("<Key>", on_key_press): Binds the on_key_press function to any key press event.

• bind("<Button-1>", on_click): Binds the on_click function to a left mouse button click event.

• The event object passed to the function contains useful information like the key that was
pressed or the coordinates of the mouse click.

5. Advanced Widgets in Tkinter

Tkinter also provides several other widgets that can be used to create more advanced applications,
including:

• Entry: For text input fields.

• Text: For multi-line text input.

• Canvas: For drawing shapes, images, or creating custom widgets.

• Menu: For creating dropdown menus.

Example 4: Using Entry, Text, and Menu Widgets

import tkinter as tk
# Function to display text from entry field

def show_entry():

entered_text = entry.get()

label.config(text=f"You entered: {entered_text}")

# Create the main window

root = tk.Tk()

root.title("Advanced Widgets Example")

# Create widgets

label = tk.Label(root, text="Enter something:", font=("Arial", 14))

entry = tk.Entry(root, width=20)

button = tk.Button(root, text="Show Entry", command=show_entry)

# Menu creation

menu = tk.Menu(root)

root.config(menu=menu)

file_menu = tk.Menu(menu)

menu.add_cascade(label="File", menu=file_menu)

file_menu.add_command(label="Exit", command=root.quit)

# Layout using grid

label.grid(row=0, column=0, padx=10, pady=10)

entry.grid(row=1, column=0, padx=10, pady=10)

button.grid(row=2, column=0, padx=10, pady=10)

# Start the Tkinter event loop

root.mainloop()

Explanation:

• Entry: A text field where users can input text.

 • Text: A widget for multiple lines of text (not shown here, but similar to Entry).

• Menu: A dropdown menu with options. In this case, we have added an "Exit" option under
the "File" menu.

• root.config(menu=menu): Sets the menu for the main window.

6. Creating a Simple Calculator using Tkinter

As a practical example, we can create a simple calculator with a GUI that performs basic arithmetic
operations.

Example 5: Simple Calculator

import tkinter as tk

def on_button_click(value):

current = entry.get()

entry.delete(0, tk.END)

entry.insert(0, current + value)

def on_clear():

entry.delete(0, tk.END)

def on_equals():

try:

result = eval(entry.get())

entry.delete(0, tk.END)

entry.insert(0, result)

except Exception as e:

entry.delete(0, tk.END)

entry.insert(0, "Error")

# Create main window

root = tk.Tk()

root.title("Simple Calculator")
# Create entry field

entry = tk.Entry(root, width=20, font=("Arial", 14))

entry.grid(row=0, column=0, columnspan=4, pady=10)

# Create buttons

buttons = [

('7', 1, 0), ('8', 1, 1), ('9', 1, 2), ('/', 1, 3),

('4', 2, 0), ('5', 2, 1), ('6', 2, 2), ('*', 2, 3),

('1', 3, 0), ('2', 3, 1), ('3', 3, 2), ('-', 3, 3),

('0', 4, 0), ('C', 4, 1), ('=', 4, 2), ('+', 4, 3),

for (text, row, col) in buttons:

if text == '=':

button = tk.Button(root, text=text, command=on_equals, width=5, height=2)

elif text == 'C':

button = tk.Button(root, text=text, command=on_clear, width=5, height=2)

else:

button = tk.Button(root, text=text, command=lambda value=text: on_button_click(value),

width=5, height=2)

button.grid(row=row, column=col, padx=5, pady=5)

# Start the Tkinter event loop

root.mainloop()

Explanation:

• This program creates a simple calculator that can perform basic arithmetic using eval() to
evaluate expressions.

• The buttons are dynamically created in a loop and placed in a grid layout.

• The on_button_click function adds digits and operators to the entry field.

• The on_equals function evaluates the expression in the entry field and displays the result.
3.Discuss in detail about SQL statements for data manipulation with example.
SQL Statements for Data Manipulation

SQL (Structured Query Language) provides several types of statements for manipulating data stored
in a relational database. The primary types of SQL statements for data manipulation are:

• SELECT: Retrieve data from one or more tables.

• INSERT: Add new records to a table.

• UPDATE: Modify existing records in a table.

• DELETE: Remove records from a table.

These SQL operations allow you to interact with and manage the data stored in the database. Let's
dive into each of these in detail, along with examples.

1. SELECT Statement

The SELECT statement is used to query the database and retrieve data from one or more tables. It is
the most commonly used SQL statement.

Syntax:

SELECT column1, column2, ...

FROM table_name

WHERE condition;

• column1, column2, ...: The columns to retrieve.

• table_name: The table from which to fetch data.

• WHERE: A condition to filter the records.

Example:

SELECT name, age

FROM employees

WHERE age > 30;

This query retrieves the name and age columns from the employees table where the age is greater
than 30.

Explanation:

• SELECT name, age: Specifies the columns to retrieve.

• FROM employees: Specifies the table to fetch the data from.

• WHERE age > 30: Filters the rows where the age column is greater than 30.
Variations:

1. Select All Columns:

2. SELECT * FROM employees;

This will fetch all columns from the employees table.

3. Using DISTINCT to Remove Duplicates:

4. SELECT DISTINCT department FROM employees;

This returns unique values from the department column.

5. Sorting with ORDER BY:

6. SELECT name, age FROM employees ORDER BY age DESC;

This sorts the result by the age column in descending order.

2. INSERT Statement

The INSERT statement is used to add new records into a table.

Syntax:

INSERT INTO table_name (column1, column2, ...)

VALUES (value1, value2, ...);

• table_name: The table where the data will be inserted.

• column1, column2, ...: The columns into which the data will be inserted.

• value1, value2, ...: The values to insert into the respective columns.

Example:

INSERT INTO employees (name, age, department)

VALUES ('John Doe', 28, 'HR');

This query inserts a new record into the employees table, specifying values for the name, age, and
department columns.

Explanation:

• INSERT INTO employees (name, age, department): Specifies the table and columns.

• VALUES ('John Doe', 28, 'HR'): Specifies the values to insert.

Variations:

1. Insert Multiple Records:

2. INSERT INTO employees (name, age, department)

3. VALUES
 4. ('Alice Smith', 35, 'Engineering'),

5. ('Bob Johnson', 40, 'Finance');

This inserts multiple records in one query.

3. UPDATE Statement

The UPDATE statement is used to modify existing records in a table.

Syntax:

UPDATE table_name

SET column1 = value1, column2 = value2, ...

WHERE condition;

• table_name: The table containing the records to modify.

• SET column1 = value1, column2 = value2, ...: Specifies the columns and their new values.

• WHERE: Filters the rows that will be updated (optional but highly recommended to avoid
updating all rows).

Example:

UPDATE employees

SET age = 29

WHERE name = 'John Doe';

This query updates the age of the employee named John Doe to 29.

Explanation:

• UPDATE employees: Specifies the table to update.

• SET age = 29: Updates the age column to 29.

• WHERE name = 'John Doe': Applies the update only to rows where the name is 'John Doe'.

Variations:

1. Update Multiple Columns:

2. UPDATE employees

3. SET age = 30, department = 'Marketing'

4. WHERE name = 'Alice Smith';

This query updates both the age and department for the employee 'Alice Smith'.

5. Update All Records:

6. UPDATE employees
 7. SET department = 'Sales';

This updates the department for all employees to 'Sales' (be cautious with such queries).

4. DELETE Statement

The DELETE statement is used to remove records from a table. You can specify a condition to delete
only certain rows.

Syntax:

DELETE FROM table_name

WHERE condition;

• table_name: The table from which to delete the data.

• WHERE: A condition to specify which rows to delete (optional but strongly recommended).

Example:

DELETE FROM employees

WHERE name = 'Bob Johnson';

This query deletes the record of the employee named 'Bob Johnson' from the employees table.

Explanation:

• DELETE FROM employees: Specifies the table from which to delete data.

• WHERE name = 'Bob Johnson': Deletes only the row where the name is 'Bob Johnson'.

Variations:

1. Delete All Records:

2. DELETE FROM employees;

This deletes all records in the employees table (without removing the table itself). Use with caution!

3. Delete Records Based on a Condition:

4. DELETE FROM employees

5. WHERE age < 25;

This deletes all employees who are younger than 25.

5. Combining Multiple Data Manipulation Statements

You can combine multiple SQL statements in a transaction to ensure data consistency and perform
complex operations.

Example: Multiple Operations in a Transaction

BEGIN;
INSERT INTO employees (name, age, department)

VALUES ('Samantha Williams', 27, 'Marketing');

UPDATE employees

SET department = 'HR'

WHERE name = 'John Doe';

DELETE FROM employees

WHERE name = 'Bob Johnson';

COMMIT;

• BEGIN;: Starts a transaction.

• COMMIT;: Commits the transaction, making all changes permanent.

• If an error occurs, you can use ROLLBACK; to undo all changes made in the transaction.

6. SQL Functions for Data Manipulation

SQL also provides several built-in functions to manipulate and aggregate data, such as:

• COUNT(): Counts the number of rows.

• SUM(): Sums the values in a numeric column.

• AVG(): Computes the average of a numeric column.

• MAX(): Returns the maximum value in a column.

• MIN(): Returns the minimum value in a column.

Example:

SELECT COUNT(*) FROM employees WHERE department = 'HR';

This query returns the total number of employees in the 'HR' department.
4.Discuss in detail about Creating simple GUI using Tkinter with example.
Creating a Simple GUI Using Tkinter in Python

Tkinter is the standard Python library for creating graphical user interfaces (GUIs). It provides a
simple way to build windows, add buttons, labels, text boxes, and other common GUI elements,
making it ideal for beginners and small desktop applications.

In this guide, we will walk through the process of creating a simple GUI using Tkinter, including how
to set up the window, add widgets (like buttons and labels), and handle events like button clicks.

1. Overview of Tkinter

Tkinter is built on the Tk GUI toolkit, which is cross-platform and provides the following key
components for building a GUI application:

• Widgets: GUI elements like buttons, labels, text boxes, etc.

• Window: A container that holds the widgets.

• Event Handling: The mechanism that listens for events (such as button clicks or keyboard
inputs) and triggers functions.

• Geometry Managers: These help to arrange and manage the position of widgets within a
window. The common geometry managers in Tkinter are pack(), grid(), and place().

2. Basic Structure of a Tkinter Program

A Tkinter program generally follows this structure:

1. Import Tkinter: Import the Tkinter module to use its components.

2. Create the main window: The main window is where all widgets are placed.

3. Create widgets: Add interactive elements like buttons, labels, and entry fields.

4. Pack or grid widgets: Organize the layout of the widgets in the window.

5. Event handling: Bind events (e.g., button clicks) to specific functions.

6. Run the Tkinter event loop: Keeps the window open and interactive.

3. Example 1: Simple Tkinter Program with a Button

Let's create a simple GUI that displays a button. When the user clicks the button, a label's text will
change.

Code Example:

import tkinter as tk
# Function that will be called when the button is clicked

def change_text():

label.config(text="Hello, Tkinter!")

# Create the main window

root = tk.Tk()

# Set the title of the window

root.title("Simple Tkinter Example")

# Set the size of the window

root.geometry("300x200")

# Create a label widget

label = tk.Label(root, text="Click the button", font=("Arial", 14))

label.pack(pady=20)

# Create a button widget

button = tk.Button(root, text="Click Me", command=change_text)

button.pack(pady=10)

# Start the Tkinter event loop to display the window

root.mainloop()

Explanation of the Code:

1. root = tk.Tk(): Creates the main window (root window).

2. root.title("Simple Tkinter Example"): Sets the window's title.

3. root.geometry("300x200"): Sets the window's dimensions (300 pixels wide by 200 pixels
tall).

4. label = tk.Label(root, text="Click the button", font=("Arial", 14)): Creates a label widget
with some text.

5. label.pack(pady=20): Adds the label widget to the window, with vertical padding of 20 pixels.
 6. button = tk.Button(root, text="Click Me", command=change_text): Creates a button widget
with the text "Click Me". The command parameter specifies the function to call when the
button is clicked.

7. root.mainloop(): Starts the Tkinter event loop, which keeps the window open and listens for
events (such as button clicks).

Behavior of the Program:

When you run the program, a window with a button will appear. When you click the button, the
label's text will change to "Hello, Tkinter!".

4. Example 2: Adding Entry Fields for User Input

Now, let's create a more interactive program that allows the user to type their name into a text entry
field and display a greeting message when they click a button.

Code Example:

import tkinter as tk

# Function that will be called when the button is clicked

def greet_user():

name = entry.get() # Get the text entered in the entry field

label.config(text=f"Hello, {name}!")

# Create the main window

root = tk.Tk()

# Set the title of the window

root.title("Name Greeting")

# Set the size of the window

root.geometry("300x200")

# Create a label widget

label = tk.Label(root, text="Enter your name:", font=("Arial", 14))

label.pack(pady=10)
# Create an entry widget for user input

entry = tk.Entry(root, font=("Arial", 14))

entry.pack(pady=10)

# Create a button widget that calls greet_user function when clicked

button = tk.Button(root, text="Greet Me", command=greet_user)

button.pack(pady=10)

# Start the Tkinter event loop

root.mainloop()

Explanation of the Code:

1. entry = tk.Entry(root, font=("Arial", 14)): Creates an entry field where users can type their
name.

2. entry.get(): Retrieves the text entered in the entry field.

3. label.config(text=f"Hello, {name}!"): Updates the label to greet the user by their name
when the button is clicked.

Behavior of the Program:

• The window shows a label prompting the user to enter their name.

• When the user types their name and clicks the "Greet Me" button, the program displays a
personalized greeting.

5. Example 3: Using Geometry Management (pack() and grid())

In Tkinter, you can arrange widgets within the window using different geometry managers: pack(),
grid(), and place(). We'll explore pack() and grid() here.

Code Example Using pack():

import tkinter as tk

root = tk.Tk()

root.title("Pack Geometry Manager")

root.geometry("300x200")

# Create a label and pack it into the window

label = tk.Label(root, text="This is a label", bg="yellow", font=("Arial", 14))

label.pack(padx=20, pady=20)

# Create a button and pack it below the label

button = tk.Button(root, text="Click Me", font=("Arial", 14))

button.pack()

root.mainloop()

In this example, we use pack() to place the label and button within the window. The padx and pady
parameters add horizontal and vertical padding, respectively.

Code Example Using grid():

import tkinter as tk

root = tk.Tk()

root.title("Grid Geometry Manager")

root.geometry("300x200")

# Create label and place it in row 0, column 0

label = tk.Label(root, text="Enter your name:", font=("Arial", 14))

label.grid(row=0, column=0, padx=10, pady=10)

# Create entry field and place it in row 1, column 0

entry = tk.Entry(root, font=("Arial", 14))

entry.grid(row=1, column=0, padx=10, pady=10)

# Create button and place it in row 2, column 0

button = tk.Button(root, text="Greet Me", font=("Arial", 14))

button.grid(row=2, column=0, pady=10)

root.mainloop()

Explanation of grid():
 • grid(row, column): Places widgets in a grid at the specified row and column.

• padx and pady: Add padding around the widgets.

6. Event Handling in Tkinter

In Tkinter, you can handle various events like button clicks, mouse movements, or keyboard presses
using event bindings.

Example: Binding a Button Click Event

import tkinter as tk

# Function to execute when the button is clicked

def on_button_click(event):

label.config(text="Button was clicked!")

root = tk.Tk()

root.title("Event Binding Example")

label = tk.Label(root, text="Click the button", font=("Arial", 14))

label.pack(pady=20)

button = tk.Button(root, text="Click Me", font=("Arial", 14))

button.pack(pady=10)

# Bind the button click event to the function

button.bind("<Button-1>", on_button_click)

root.mainloop()

Explanation:

• button.bind("<Button-1>", on_button_click): This binds the left mouse button click (Button-
1) to the on_button_click function. When the button is clicked, the label's text is updated.