Python Decorators

1
Decorators in Python
Decorators are very powerful and useful tool in Python since it allows
programmers to modify the behavior of function or class. Decorators allow us
to wrap another function in order to extend the behavior of the wrapped
function, without permanently modifying it. But before diving deep into
decorators let us understand some concepts that will come in handy in
learning the decorators.
First Class Objects
In Python, functions are first class objects that means that functions in
Python can be used or passed as arguments.
Properties of first class functions:
 A function is an instance of the Object type.
 You can store the function in a variable.
 You can pass the function as a parameter to another function.
 You can return the function from a function.
 You can store them in data structures such as hash tables, lists, …
Consider the below examples for better understanding.
Example 1: Treating the functions as objects.
# Python program to illustrate functions

# can be treated as objects
def shout(text):
return text.upper()
print(shout('Hello'))
yell = shout
print(yell('Hello'))
Output:
HELLO
HELLO
In the above example, we have assigned the function shout to a variable.
This will not call the function instead it takes the function object referenced
by shout and creates a second name pointing to it, yell.
What are the functions in Python?

Python has the most interesting feature that everything is treated as an object even
classes or any variable we define in Python is also assumed as an object. Functions
are first-class objects in the Python because they can reference to, passed to a
variable and returned from other functions as well. The example is given below:
2
1. def func1(msg):
2. print(msg)
3. func1("Hii")
4. func2 = func1
5. func2("Hii")
Output:
Hii
Hii
In the above program, when we run the code it give the same output for both
functions. The func2 referred to function func1 and act as function. We need to
understand the following concept of the function:
o The function can be referenced and passed to a variable and returned from
other functions as well.
o The functions can be declared inside another function and passed as an
argument to another function.
Inner Function
Python provides the facility to define the function inside another function. These
types of functions are called inner functions. Consider the following example:
1. def func():
2. print("We are in first function")
3. def func1():
4. print("This is first child function")
5. def func2():
6. print(" This is second child function")
7. func1()
8. func2()
9. func()
Output:
We are in first function

This is first child function
This is second child function
In the above program, it doesn't matter how the child functions are declared. The
execution of the child function makes effect on the output. These child functions are
locally bounded with the func() so they cannot be called separately.
3
A function that accepts other function as an argument is also called higher order
function. Consider the following example:
1. def add(x):
2. return x+1
3. def sub(x):
4. return x-1
5. def operator(func, x):
6. temp = func(x)
7. return temp
8. print(operator(sub,10))
9. print(operator(add,20))
Output:
9
21
In the above program, we have passed the sub() function and add() function as
argument in operator() function.
A function can return another function. Consider the below example:
1. def hello():
2. def hi():
3. print("Hello")
4. return hi
5. new = hello()
6. new()
Output:
Hello
In the above program, the hi() function is nested inside the hello() function. It will
return each time we call hi().
Decorators
As stated above the decorators are used to modify the behavior of function
or class. In Decorators, functions are taken as the argument into another
function and then called inside the wrapper function.
Syntax for Decorator:
@gfg_decorator
def hello_decorator():
4
print("Gfg")
'''Above code is equivalent to -
def hello_decorator():
print("Gfg")
hello_decorator = gfg_decorator(hello_decorator)'''
In the above code, gfg_decorator is a callable function, will add some code
on the top of some another callable function, hello_decorator function and
return the wrapper function.
Decorator can modify the behavior:
# defining a decorator
def hello_decorator(func):
# inner1 is a Wrapper function in

# which the argument is called
# inner function can access the outer local

# functions like in this case "func"
def inner1():
print("Hello, this is before function execution")
# calling the actual function now

# inside the wrapper function.
func()
print("This is after function execution")
return inner1
# defining a function, to be called inside wrapper

def function_to_be_used():
print("This is inside the function !!")
# passing 'function_to_be_used' inside the

# decorator to control its behavior
function_to_be_used = hello_decorator(function_to_be_used)
5
# calling the function

function_to_be_used()
Output:
Hello, this is before function execution
This is inside the function !!
This is after function execution
Let’s see the behavior of the above code how it runs step by step when the
“function_to_be_used” is called.
Reusing Decorator
We can reuse the decorator as well by recalling that decorator function. Let's make
the decorator to its own module that can be used in many other functions. Creating
a file called mod_decorator.py with the following code:
1. def do_twice(func):
2. def wrapper_do_twice():
3. func()
4. func()
5. return wrapper_do_twice
We can import mod_decorator.py in other file.
1. from decorator import do_twice

2. @do_twice
3. def say_hello():
4. print("Hello There")
5. say_hello()
Output:
Hello There
Hello There
Python Decorator with Argument

We want to pass some arguments in function. Let's do it in following code:

2. @do_twice
6
3. def display(name):
4. print(f"Hello {name}")
5. display()
Output:
TypeError: display() missing 1 required positional argument: 'name'
As we can see that, the function didn't accept the argument. Running this code
raises an error. We can fix this error by using *args and **kwargs in the inner
wrapper function. Modifying the decorator.py as follows:
1. def do_twice(func):
2. def wrapper_function(*args,**kwargs):
3. func(*args,**kwargs)
4. func(*args,**kwargs)
5. return wrapper_function
Now wrapper_function() can accept any number of argument and pass them on
the function.

2. @do_twice
3. def display(name):
4. print(f"Hello {name}")
5. display("John")
Output:
Hello John
Hello John
Returning Values from Decorated Functions

We can control the return type of the decorated function. The example is given
below:

2. @do_twice
3. def return_greeting(name):
4. print("We are created greeting")
5. return f"Hi {name}"
6. hi_adam = return_greeting("Adam")
Output:
7
We are created greeting

We are created greeting
Fancy Decorators
Let's understand the fancy decorators by the following topic:
Class Decorators
Python provides two ways to decorate a class. Firstly, we can decorate the method
inside a class; there are built-in decorators like @classmethod,
@staticmethod and @property in Python.
The @classmethod and @staticmethod define methods inside class that is not
connected to any other instance of a class. The @property is generally used to
modify the getters and setters of a class attributes. Let’s understand it by the
following example:
Example: 1- @property decorator - By using it, we can use the class function as
an attribute. Consider the following code:
1. class Student:
2. def __init__(self,name,grade):
3. self.name = name
4. self.grade = grade
5. @property
6. def display(self):
7. return self.name + " got grade " + self.grade
8.
9. stu = Student("John","B")
10.print("Name:", stu.name)
11.print("Grade:", stu.grade)
12.print(stu.display)
Output:
Name: John
Grade: B
John got grade B
Example:2 - @staticmethod decorator- The @staticmethod is used to define a

static method in the class. It is called by using the class name as well as instance of
the class. Consider the following code:
1. class Person:
2. @staticmethod
8
3. def hello():
4. print("Hello Peter")
5. per = Person()
6. per.hello()
7. Person.hello()
Output:
Hello Peter
Hello Peter
Singleton Class
A singleton class only has one instance. There are many singletons in Python
including True, None, etc.
Nesting Decorators
We can use multiple decorators by using them on top of each other. Let's consider
the following example:
1. @function1
2. @function2
3. def function(name):
4. print(f "{name}")
In the above code, we have used the nested decorator by stacking them onto one
another.
Decorator with Arguments
It is always useful to pass arguments in a decorator. The decorator can be executed

several times according to the given value of the argument. Let us consider the
following example:
1. Import functools
2.
3. def repeat(num):
4.
5. #Creating and returning a wrapper function
6. def decorator_repeat(func):
7. @functools.wraps(func)
8. def wrapper(*args,**kwargs):
9. for _ in range(num):
9
10. value = func(*args,**kwargs)

11. return value
12. return wrapper
13. return decorator_repeat
14.
15.#Here we are passing num as an argument which repeats the print function
16.@repeat(num=5)
17.def function1(name):
18. print(f"{name}")
Output:
JavatPoint
JavatPoint
JavatPoint
JavatPoint
JavatPoint
In the above example, @repeat refers to a function object that can be called in
another function. The @repeat(num = 5) will return a function which acts as a
decorator.
The above code may look complex but it is the most commonly used decorator
pattern where we have used one additional def that handles the arguments to the
decorator.
Note: Decorator with argument is not frequently used in programming, but it

provides flexibility. We can use it with or without argument.
Classes as Decorators
The classes are the best way to maintain state. In this section, we will learn how to
use a class as a decorator. Here we will create a class that contains __init__() and
take func as an argument. The class needs to be callable so that it can stand in for
the decorated function.
To making a class callable, we implement the special __call__() method.
1. import functools
2.
3. class Count_Calls:
4. def __init__(self, func):
5. functools.update_wrapper(self, func)
6. self.func = func
7. self.num_calls = 0
8.
10
9. def __call__(self, *args, **kwargs):

10.self.num_calls += 1
11.print(f"Call{self.num_calls} of {self.func.__name__!r}")
12.return self.func(*args, **kwargs)
13.
14.@Count_Calls
15.def say_hello():
16.print("Say Hello")
17.
18.say_hello()
19.say_hello()
20.say_hello()
Output:
Call 1 of 'say_hello'
Say Hello
Say Hello
Say Hello
Python Generators
What is Python Generator?
Python Generators are the functions that return the traversal object and used to
create iterators. It traverses the entire items at once. The generator can also be an
expression in which syntax is similar to the list comprehension in Python.
There is a lot of complexity in creating iteration in Python; we need to

implement __iter__() and __next__() method to keep track of internal states.
It is a lengthy process to create iterators. That's why the generator plays an

essential role in simplifying this process. If there is no value found in iteration, it
raises StopIteration exception.
11
How to Create Generator function in

Python?
It is quite simple to create a generator in Python. It is similar to the normal function
defined by the def keyword and uses a yield keyword instead of return. Or we can
say that if the body of any function contains a yield statement, it automatically
becomes a generator function. Consider the following example:
1. def simple():
2. for i in range(10):
3. if(i%2==0):
4. yield i
5.
6. #Successive Function call using for loop
7. for i in simple():
8. print(i)
Output:
0
2
4
6
8
yield vs. return

The yield statement is responsible for controlling the flow of the generator function.
It pauses the function execution by saving all states and yielded to the caller. Later
it resumes execution when a successive function is called. We can use the multiple
yield statement in the generator function.
The return statement returns a value and terminates the whole function and only
one return statement can be used in the function.
Using multiple yield Statement
We can use the multiple yield statement in the generator function. Consider the
following example.
1. def multiple_yield():
2. str1 = "First String"
3. yield str1
4.
5. str2 = "Second string"
6. yield str2
12
7.
8. str3 = "Third String"
9. yield str3
10.obj = multiple_yield()
11.print(next(obj))
12.print(next(obj))
13.print(next(obj))
Output:
First String
Second string
Third String
Difference between Generator function and Normal

function
o Normal function contains only one Lreturn statement whereas generator
function can contain one or more yield statement.
o When the generator functions are called, the normal function is paused
immediately and control transferred to the caller.
o Local variable and their states are remembered between successive calls.
o StopIteration exception is raised automatically when the function terminates.
Next →← Prev
Python Generators
What is Python Generator?
Python Generators are the functions that return the traversal object and used to
create iterators. It traverses the entire items at once. The generator can also be
an expression in which syntax is similar to the list comprehension in Python.
There is a lot of complexity in creating iteration in Python; we need to

implement __iter__() and __next__() method to keep track of internal states.
It is a lengthy process to create iterators. That's why the generator plays an

essential role in simplifying this process. If there is no value found in iteration, it
raises StopIteration exception.
13
How to Create Generator function in

Python?
It is quite simple to create a generator in Python. It is similar to the normal
function defined by the def keyword and uses a yield keyword instead of return.
Or we can say that if the body of any function contains a yield statement, it
automatically becomes a generator function. Consider the following example:
1. def simple():
2. for i in range(10):
3. if(i%2==0):
4. yield i
5.
6. #Successive Function call using for loop
7. for i in simple():
8. print(i)
Output:
0
2
4
6
8
yield vs. return
The yield statement is responsible for controlling the flow of the generator
function. It pauses the function execution by saving all states and yielded to the
caller. Later it resumes execution when a successive function is called. We can
use the multiple yield statement in the generator function.
The return statement returns a value and terminates the whole function and only
one return statement can be used in the function.
Using multiple yield Statement
We can use the multiple yield statement in the generator function. Consider the
following example.
14
1. def multiple_yield():
2. str1 = "First String"
3. yield str1
4.
5. str2 = "Second string"
6. yield str2
7.
8. str3 = "Third String"
9. yield str3
10.obj = multiple_yield()
11.print(next(obj))
12.print(next(obj))
13.print(next(obj))
Output:
First String
Second string
Third String
Difference between Generator function and

Normal function
o Normal function contains only one Lreturn statement whereas generator
function can contain one or more yield statement.
o When the generator functions are called, the normal function is paused
immediately and control transferred to the caller.
o Local variable and their states are remembered between successive calls.
o StopIteration exception is raised automatically when the function

terminates.
Generator Expression
We can easily create a generator expression without using user-defined function.

It is the same as the lambda function which creates an anonymous function; the
generator's expressions create an anonymous generator function.
The representation of generator expression is similar to the Python list

comprehension. The only difference is that square bracket is replaced by
15
round parentheses. The list comprehension calculates the entire list, whereas
the generator expression calculates one item at a time.
Consider the following example:
1. list = [1,2,3,4,5,6,7]
2.
3. # List Comprehension
4. z = [x**3 for x in list]
5.
6. # Generator expression
7. a = (x**3 for x in list)
8.
9. print(a)
10.print(z)
Output:
<generator object <genexpr> at 0x01BA3CD8>

[1, 8, 27, 64, 125, 216, 343]
In the above program, list comprehension has returned the list of cube of
elements whereas generator expression has returned the reference of calculated
value. Instead of applying a for loop, we can also call next() on the generator
object. Let's consider another example:
1. list = [1,2,3,4,5,6]
2.
3. z = (x**3 for x in list)
4.
5. print(next(z))
6.
7. print(next(z))
8.
9. print(next(z))
10.
11.print(next(z))
16
Output:
1
8
27
64
Python MySQL
Environment Setup
To build the real world applications, connecting with the databases is the necessity
for the programming languages. However, python allows us to connect our
application to the databases like MySQL, SQLite, MongoDB, and many others.
In this section of the tutorial, we will discuss Python - MySQL connectivity, and we
will perform the database operations in python. We will also cover the Python
connectivity with the databases like MongoDB and SQLite later in this tutorial.
Install mysql.connector
To connect the python application with the MySQL database, we must import the
mysql.connector module in the program.
The mysql.connector is not a built-in module that comes with the python installation.
We need to install it to get it working.
Execute the following command to install it using pip installer.
1. > python -m pip install mysql-connector
Or follow the following steps.
1. Click the link:
https://files.pythonhosted.org/packages/8f/6d/
fb8ebcbbaee68b172ce3dfd08c7b8660d09f91d8d5411298bcacbd309f96/mysql-
connector-python-8.0.13.tar.gz to download the source code.
2. Extract the archived file.
3. Open the terminal (CMD for windows) and change the present working directory
to the source code directory.
1. $ cd mysql-connector-python-8.0.13/
4. Run the file named setup.py with python (python3 in case you have also installed
python 2) with the parameter build.
17
1. $ python setup.py build
5. Run the following command to install the mysql-connector.
1. $ python setup.py install
This will take a bit of time to install mysql-connector for python. We can verify the
installation once the process gets over by importing mysql-connector on the python
shell.
Hence, we have successfully installed mysql-connector for python on our system.
Database Connection
In this section of the tutorial, we will discuss the steps to connect the python
application to the database.
There are the following steps to connect a python application to our database.
1. Import mysql.connector module
2. Create the connection object.
3. Create the cursor object
4. Execute the query
Creating the connection

To create a connection between the MySQL database and the python application, the
connect() method of mysql.connector module is used.
Pass the database details like HostName, username, and the database password in
the method call. The method returns the connection object.
The syntax to use the connect() is given below.

18
1. Connection-Object= mysql.connector.connect(host = <host-name> , user =

<username> , passwd = <password> )
Consider the following example.
Example
1. import mysql.connector
2.
3. #Create the connection object
4. myconn = mysql.connector.connect(host = "localhost", user = "root",passwd
= "google")
5.
6. #printing the connection object
7. print(myconn)
Output:
<mysql.connector.connection.MySQLConnection object at 0x7fb142edd780>
Here, we must notice that we can specify the database name in the connect()
method if we want to connect to a specific database.
Example
2.
= "google", database = "mydb")
5.
7. print(myconn)
Output:
<mysql.connector.connection.MySQLConnection object at 0x7ff64aa3d7b8>
Creating a cursor object

The cursor object can be defined as an abstraction specified in the Python DB-API
2.0. It facilitates us to have multiple separate working environments through the
same connection to the database. We can create the cursor object by calling the
'cursor' function of the connection object. The cursor object is an important aspect of
executing queries to the databases.
19
The syntax to create the cursor object is given below.
1. <my_cur> = conn.cursor()
Example
= "google", database = "mydb")
4.
6. print(myconn)
7.
8. #creating the cursor object
9. cur = myconn.cursor()
10.
11.print(cur)
Output:
<mysql.connector.connection.MySQLConnection object at 0x7faa17a15748>

MySQLCursor: (Nothing executed yet)
Creating new databases

In this section of the tutorial, we will create the new database PythonDB.
Getting the list of existing databases

We can get the list of all the databases by using the following MySQL query.
1. > show databases;
Example
2.
= "google")
5.
20
8.
9. try:
10. dbs = cur.execute("show databases")
11.except:
12. myconn.rollback()
13.for x in cur:
14. print(x)
15.myconn.close()
Output:
('EmployeeDB',)
('Test',)
('TestDB',)
('information_schema',)
('javatpoint',)
('javatpoint1',)
('mydb',)
('mysql',)
('performance_schema',)
('testDB',)
Creating the new database

The new database can be created by using the following SQL query.
1. > create database <database-name>
Example
2.
= "google")
5.
8.
9. try:
10. #creating a new database
11. cur.execute("create database PythonDB2")
12.
21
13. #getting the list of all the databases which will now include the new databa
se PythonDB
14. dbs = cur.execute("show databases")
15.
16.except:
18.
19.for x in cur:
20. print(x)
21.
22.myconn.close()
Creating the table

In this section of the tutorial, we will create the new table Employee. We have to
mention the database name while establishing the connection object.
We can create the new table by using the CREATE TABLE statement of SQL. In our
database PythonDB, the table Employee will have the four columns, i.e., name, id,
salary, and department_id initially.
The following query is used to create the new table Employee.
1. > create table Employee (name varchar(20) not null, id int primary key, sala
ry float not null, Dept_Id int not null)
Example
2.
= "google",database = "PythonDB")
5.
8.
9. try:
10. #Creating a table with name Employee having four columns i.e., name, id,
salary, and department id
11. dbs = cur.execute("create table Employee(name varchar(20) not null, id in
t(20) not null primary key, salary float not null, Dept_id int not null)")
22
12.except:
14.
15.myconn.close()
Now, we may check that the table Employee is present in the database.
Alter Table
Sometimes, we may forget to create some columns, or we may need to update the
table schema. The alter statement used to alter the table schema if required. Here,
we will add the column branch_name to the table Employee. The following SQL
query is used for this purpose.
1. alter table Employee add branch_name varchar(20) not null
Example
2.
5.
8.
9. try:
10. #adding a column branch name to the table Employee
11. cur.execute("alter table Employee add branch_name varchar(20) not null")
12.except:
14.
15.myconn.close()
23
Insert Operation
Adding a record to the table
The INSERT INTO statement is used to add a record to the table. In python, we
can mention the format specifier (%s) in place of values.
We provide the actual values in the form of tuple in the execute() method of the
cursor.
Example
6. sql = "insert into Employee(name, id, salary, dept_id, branch_name) values (
%s, %s, %s, %s, %s)"
7.
8. #The row values are provided in the form of tuple
9. val = ("John", 110, 25000.00, 201, "Newyork")
10.
11.try:
12. #inserting the values into the table
13. cur.execute(sql,val)
14.
15. #commit the transaction
16. myconn.commit()
17.
18.except:
20.
21.print(cur.rowcount,"record inserted!")
22.myconn.close()
Output:
24
1 record inserted!
Insert multiple rows

We can also insert multiple rows at once using the python script. The multiple rows
are mentioned as the list of various tuples.
Each element of the list is treated as one particular row, whereas each element of
the tuple is treated as one particular column value (attribute).
Example
2.
5.
%s, %s, %s, %s, %s)"
9. val = [("John", 102, 25000.00, 201, "Newyork"),
("David",103,25000.00,202,"Port of spain"),
("Nick",104,90000.00,201,"Newyork")]
10.
11.try:
13. cur.executemany(sql,val)
14.
16. myconn.commit()
17. print(cur.rowcount,"records inserted!")
18.
19.except:
21.
25
22.myconn.close()
Output:
3 records inserted!
Row ID
In SQL, a particular row is represented by an insertion id which is known as row id.
We can get the last inserted row id by using the attribute lastrowid of the cursor
object.
Example
6.
%s, %s, %s, %s, %s)"
8.
9. val = ("Mike",105,28000,202,"Guyana")
10.
11.try:
13. cur.execute(sql,val)
14.
16. myconn.commit()
17.
18. #getting rowid
19. print(cur.rowcount,"record inserted! id:",cur.lastrowid)
20.
21.except:
26
23.
24.myconn.close()
Output:
1 record inserted! Id: 0
Read Operation
The SELECT statement is used to read the values from the databases. We can
restrict the output of a select query by using various clause in SQL like where, limit,
etc.
Python provides the fetchall() method returns the data stored inside the table in the
form of rows. We can iterate the result to get the individual rows.
In this section of the tutorial, we will extract the data from the database by using
the python script. We will also format the output to print it on the console.
Example
2.
5.
8.
9. try:
10. #Reading the Employee data
11. cur.execute("select * from Employee")
12.
13. #fetching the rows from the cursor object
14. result = cur.fetchall()
15. #printing the result
16.
17. for x in result:
18. print(x);
19.except:
27
21.
22.myconn.close()
Output:
('John', 101, 25000.0, 201, 'Newyork')

('John', 102, 25000.0, 201, 'Newyork')
('David', 103, 25000.0, 202, 'Port of spain')
('Nick', 104, 90000.0, 201, 'Newyork')
('Mike', 105, 28000.0, 202, 'Guyana')
Reading specific columns

We can read the specific columns by mentioning their names instead of using star
(*).
In the following example, we will read the name, id, and salary from the Employee
table and print it on the console.
Example
6. try:
8. cur.execute("select name, id, salary from Employee")
9.
13. for x in result:
14. print(x);
15.except:
17.myconn.close()
Output:
28
('John', 101, 25000.0)

('John', 102, 25000.0)
('David', 103, 25000.0)
('Nick', 104, 90000.0)
('Mike', 105, 28000.0)
The fetchone() method

The fetchone() method is used to fetch only one row from the table. The fetchone()
method returns the next row of the result-set.
Example
2.
5.
8.
9. try:
12.
13. #fetching the first row from the cursor object
14. result = cur.fetchone()
15.
17. print(result)
18.
19.except:
21.
22.myconn.close()
Output:
('John', 101, 25000.0)

29
Formatting the result

We can format the result by iterating over the result produced by the fetchall() or
fetchone() method of cursor object since the result exists as the tuple object which
is not readable.
Example
2.
5.
8.
9. try:
10.
13.
16.
17. print("Name id Salary");
18. for row in result:
19. print("%s %d %d"%(row[0],row[1],row[2]))
20.except:
22.
23.myconn.close()
Output:
Name id Salary
John 101 25000
John 102 25000
30
David 103 25000

Nick 104 90000
Mike 105 28000
Using where clause

We can restrict the result produced by the select statement by using the where
clause. This will extract only those columns which satisfy the where condition.
Example: printing the names that start with j

2.
5.
8.
9. try:
11. cur.execute("select name, id, salary from Employee where name like 'J
%'")
12.
15.
17.
20.except:
22.
23.myconn.close()
Output:
31
Name id Salary
John 101 25000
John 102 25000
Example: printing the names with id = 101, 102,

and 103
2.
5.
8.
9. try:
11. cur.execute("select name, id, salary from Employee where id in (101,102,1
03)")
12.
15.
17.
20.except:
22.
23.myconn.close()
Output:
Name id Salary
John 101 25000
John 102 25000
David 103 2500
Ordering the result

32
The ORDER BY clause is used to order the result. Consider the following example.
Example
2.
5.
8.
9. try:
11. cur.execute("select name, id, salary from Employee order by name")
12.
15.
17.
20.except:
22.
23.myconn.close()
Output:
Name id Salary
David 103 25000
John 101 25000
John 102 25000
Mike 105 28000
Nick 104 90000
Order by DESC
This orders the result in the decreasing order of a particular column.
33
Example
2.
5.
8.
9. try:
11. cur.execute("select name, id, salary from Employee order by name desc")
12.
15.
20.
21.except:
23.
24.myconn.close()
Output:
Name id Salary
Nick 104 90000
Mike 105 28000
John 101 25000
John 102 25000
David 103 25000
Update Operation
The UPDATE-SET statement is used to update any column inside the table. The
following SQL query is used to update a column.
34
1. > update Employee set name = 'alex' where id = 110
Example
2.
5.
8.
9. try:
10. #updating the name of the employee whose id is 110
11. cur.execute("update Employee set name = 'alex' where id = 110")
12. myconn.commit()
13.except:
14.
16.
17.myconn.close()
Delete Operation
The DELETE FROM statement is used to delete a specific record from the table. Here,
we must impose a condition using WHERE clause otherwise all the records from the
table will be removed.
The following SQL query is used to delete the employee detail whose id is 110 from
the table.
1. > delete from Employee where id = 110
Example
2.
35

5.
8.
9. try:
10. #Deleting the employee details whose id is 110
11. cur.execute("delete from Employee where id = 110")
12. myconn.commit()
13.except:
14.
16.
17.myconn.close()
Join Operation
We can combine the columns from two or more tables by using some common
column among them by using the join statement.
We have only one table in our database, let's create one more table Departments
with two columns department_id and department_name.
1. create table Departments (Dept_id int(20) primary key not null, Dept_Name
varchar(20) not null);
As we have created a new table Departments as shown in the above image.

However, we haven't yet inserted any value inside it.
Pause
Unmute
Loaded: 25.49%
Fullscreen
Let's insert some Departments ids and departments names so that we can map this
to our Employee table.
1. insert into Departments values (201, "CS");

2. insert into Departments values (202, "IT");
36
Let's look at the values inserted in each of the tables. Consider the following image.
Now, let's create a python script that joins the two tables on the common column,
i.e., dept_id.
Example
2.
5.
8.
9. try:
10. #joining the two tables on departments_id
11. cur.execute("select Employee.id, Employee.name, Employee.salary, Depart
ments.Dept_id, Departments.Dept_Name from Departments join Employee o
n Departments.Dept_id = Employee.Dept_id")
12. print("ID Name Salary Dept_Id Dept_Name")
37
13. for row in cur:

14. print("%d %s %d %d %s"%(row[0], row
[1],row[2],row[3],row[4]))
15.
16.except:
18.
19.myconn.close()
Output:
ID Name Salary Dept_Id Dept_Name

101 John 25000 201 CS
102 John 25000 201 CS
103 David 25000 202 IT
104 Nick 90000 201 CS
105 Mike 28000 202 IT
Right Join
Right join shows all the columns of the right-hand side table as we have two tables
in the database PythonDB, i.e., Departments and Employee. We do not have any
Employee in the table who is not working for any department (Employee for which
department id is null). However, to understand the concept of right join let's create
the one.
Execute the following query on the MySQL server.
1. insert into Employee(name, id, salary, branch_name) values ("Alex",108,299

00,"Mumbai");
This will insert an employee Alex who doesn't work for any department (department
id is null).
Now, we have an employee in the Employee table whose department id is not

present in the Departments table. Let's perform the right join on the two tables now.
Example
2.
5.
38

8.
9. try:
11. result = cur.execute("select Employee.id, Employee.name, Employee.salar
y, Departments.Dept_id, Departments.Dept_Name from Departments right joi
n Employee on Departments.Dept_id = Employee.Dept_id")
12.
14.
15. for row in cur:
16. print(row[0]," ", row[1]," ",row[2]," ",row[3]," ",row[4])
17.
18.
19.
20.except:
22.
23.myconn.close()
Output:

101 John 25000.0 201 CS
102 John 25000.0 201 CS
103 David 25000.0 202 IT
104 Nick 90000.0 201 CS
105 Mike 28000.0 202 IT
108 Alex 29900.0 None None
Left Join
The left join covers all the data from the left-hand side table. It has just opposite
effect to the right join. Consider the following example.
Example
2.
39

5.
8.
9. try:
11. result = cur.execute("select Employee.id, Employee.name, Employee.salar
y, Departments.Dept_id, Departments.Dept_Name from Departments left join
Employee on Departments.Dept_id = Employee.Dept_id")
13. for row in cur:
14. print(row[0]," ", row[1]," ",row[2]," ",row[3]," ",row[4])
15.
16.
17.
18.except:
20.
21.myconn.close()
Output:

101 John 25000.0 201 CS
102 John 25000.0 201 CS
103 David 25000.0 202 IT
104 Nick 90000.0 201 CS
105 Mike 28000.0 202 IT
Performing Transactions
Transactions ensure the data consistency of the database. We have to make sure
that more than one applications must not modify the records while performing the
database operations. The transactions have the following properties.
1. Atomicity
Either the transaction completes, or nothing happens. If a transaction
contains 4 queries then all these queries must be executed, or none of them
must be executed.
40
2. Consistency
The database must be consistent before the transaction starts and the
database must also be consistent after the transaction is completed.
3. Isolation
Intermediate results of a transaction are not visible outside the current
transaction.
4. Durability
Once a transaction was committed, the effects are persistent, even after a
system failure.
Python commit() method

Python provides the commit() method which ensures the changes made to
the database consistently take place.
The syntax to use the commit() method is given below.
1. conn.commit() #conn is the connection object
All the operations that modify the records of the database do not take place until the
commit() is called.
Python rollback() method

The rollback() method is used to revert the changes that are done to the database.
This method is useful in the sense that, if some error occurs during the database
operations, we can rollback that transaction to maintain the database consistency.
The syntax to use the rollback() is given below.
1. Conn.rollback()
Closing the connection

We need to close the database connection once we have done all the operations
regarding the database. Python provides the close() method. The syntax to use the
close() method is given below.
41
1. conn.close()
In the following example, we are deleting all the employees who are working for the
CS department.
Example
2.
5.
8.
9. try:
10. cur.execute("delete from Employee where Dept_id = 201")
11. myconn.commit()
12. print("Deleted !")
13.except:
14. print("Can't delete !")
16.
17.myconn.close()
Output:
Deleted !
MongoDB Tutorial
MongoDB tutorial provides basic and advanced concepts of SQL. Our MongoDB
tutorial is designed for beginners and professionals.
MongoDB is a No SQL database. It is an open-source, cross-platform, document-

oriented database written in C++.
Our MongoDB tutorial includes all topics of MongoDB database such as insert
documents, update documents, delete documents, query documents, projection,
sort() and limit() methods, create a collection, drop collection, etc. There are also
given MongoDB interview questions to help you better understand the MongoDB
database.
42
What is MongoDB
MongoDB is an open-source document database that provides high performance,
high availability, and automatic scaling.
In simple words, you can say that - Mongo DB is a document-oriented database. It

is an open source product, developed and supported by a company named 10gen.
MongoDB is available under General Public license for free, and it is also available
under Commercial license from the manufacturer.
The manufacturing company 10gen has defined MongoDB as:
"MongoDB is a scalable, open source, high performance, document-oriented

database." - 10gen
MongoDB was designed to work with commodity servers. Now it is used by the
company of all sizes, across all industry.
History of MongoDB
The initial development of MongoDB began in 2007 when the company was building
a platform as a service similar to window azure.
Window azure is a cloud computing platform and infrastructure, created by Microsoft, to build,
deploy and manage applications and service through a global network.
MongoDB was developed by a NewYork based organization named 10gen which is

now known as MongoDB Inc. It was initially developed as a PAAS (Platform as a
Service). Later in 2009, it is introduced in the market as an open source database
server that was maintained and supported by MongoDB Inc.
The first ready production of MongoDB has been considered from version 1.4 which
was released in March 2010.
MongoDB2.4.9 was the latest and stable version which was released on January 10,
2014.
Purpose of building MongoDB

It may be a very genuine question that - "what was the need of MongoDB although
there were many databases in action?"
There is a simple answer:
All the modern applications require big data, fast features development, flexible
deployment, and the older database systems not competent enough, so the
MongoDB was needed.
43
The primary purpose of building MongoDB is:
o Scalability
o Performance
o High Availability
o Scaling from single server deployments to large, complex multi-site

architectures.
o Key points of MongoDB
o Develop Faster
o Deploy Easier
o Scale Bigger
First of all, we should know what is document oriented database?
Example of document oriented database

MongoDB is a document oriented database. It is a key feature of MongoDB. It offers
a document oriented storage. It is very simple you can program it easily.
MongoDB stores data as documents, so it is known as document-oriented database.
1. FirstName = "John",
2. Address = "Detroit",
3. Spouse = [{Name: "Angela"}].
4. FirstName ="John",
5. Address = "Wick"
There are two different documents (separated by ".").
Storing data in this manner is called as document-oriented database.
Mongo DB falls into a class of databases that calls Document Oriented Databases.
There is also a broad category of database known as No SQL Databases.
Features of MongoDB
These are some important features of MongoDB:
1. Support ad hoc queries

44
In MongoDB, you can search by field, range query and it also supports regular
expression searches.
2. Indexing
You can index any field in a document.
3. Replication
MongoDB supports Master Slave replication.
A master can perform Reads and Writes and a Slave copies data from the master
and can only be used for reads or back up (not writes)
4. Duplication of data
MongoDB can run over multiple servers. The data is duplicated to keep the system
up and also keep its running condition in case of hardware failure.
5. Load balancing
It has an automatic load balancing configuration because of data placed in shards.
6. Supports map reduce and aggregation tools.
7. Uses JavaScript instead of Procedures.
8. It is a schema-less database written in C++.
9. Provides high performance.
10. Stores files of any size easily without complicating your stack.
11. Easy to administer in the case of failures.
12. It also supports:
JSON data model with dynamic schemas
Auto-sharding for horizontal scalability
Built in replication for high availability
Now a day many companies using MongoDB to create new types of applications,
improve performance and availability.
Prerequisite
Before learning MongoDB, you must have the basic knowledge of SQL and OOPs.
45
Audience
Our MongoDB tutorial is designed to help beginners and professionals.
Problem
We assure that you will not find any problem in this MongoDB tutorial. But if there is
any mistake, please post the problem in contact form.
MongoDB advantages over RDBMS

In recent days, MongoDB is a new and popularly used database. It is a document
based, non relational database provider.
Although it is 100 times faster than the traditional database but it is early to say
that it will broadly replace the traditional RDBMS. But it may be very useful in term
to gain performance and scalability.
A Relational database has a typical schema design that shows number of tables and
the relationship between these tables, while in MongoDB there is no concept of
relationship.
MongoDB Advantages
o MongoDB is schema less. It is a document database in which one collection
holds different documents.
o There may be difference between number of fields, content and size of
the document from one to other.
o Structure of a single object is clear in MongoDB.
o There are no complex joins in MongoDB.
o MongoDB provides the facility of deep query because it supports a powerful

dynamic query on documents.
o It is very easy to scale.
o It uses internal memory for storing working sets and this is the reason
of its fast access.
Distinctive features of MongoDB

o Easy to use
46
o Light Weight
o Extremely faster than RDBMS
Where MongoDB should be used

o Big and complex data
o Mobile and social infrastructure
o Content management and delivery
o User data management
o Data hub
Performance analysis of MongoDB and

RDBMS
o In relational database (RDBMS) tables are using as storing elements, while in
MongoDB collection is used.
o In the RDBMS, we have multiple schema and in each schema we create tables
to store data while, MongoDB is a document oriented database in which data
is written in BSON format which is a JSON like format.
o MongoDB is almost 100 times faster than traditional database systems.
MongoDB Datatypes
Following is a list of usable data types in MongoDB.
Data Types Description
String String is the most commonly used datatype. It is used to store

data. A string must be UTF 8 valid in mongodb.
Integer Integer is used to store the numeric value. It can be 32 bit or

64 bit depending on the server you are using.
Boolean This datatype is used to store boolean values. It just shows

47
YES/NO values.
Double Double datatype stores floating point values.
Min/Max This datatype compare a value against the lowest and highest
Keys bson elements.
Arrays This datatype is used to store a list or multiple values into a

single key.
Object Object datatype is used for embedded documents.
Null It is used to store null values.
Symbol It is generally used for languages that use a specific type.
Date This datatype stores the current date or time in unix time
format. It makes you possible to specify your own date time by
creating object of date and pass the value of date, month, year
into it.
Python MongoDB Connectivity

To create connection between Python programming language and MongoDB
database, we need to first install pymongo driver. Here, we are creating an
example that connects to the database and performs basic database operations.
This example includes the following steps:
1) Install Driver
1. $ pip install pymongo
48
2) Create Python File

// connect.py
1. from pymongo import MongoClient # import mongo client to connect

2. import pprint
3. # Creating instance of mongoclient
4. client = MongoClient()
5. # Creating database
6. db = client.javatpoint
7. employee = {"id": "101",
8. "name": "Peter",
9. "profession": "Software Engineer",
10.}
11.# Creating document
12.employees = db.employees
13.# Inserting data
14.employees.insert_one(employee)
15.# Fetching data
16.pprint.pprint(employees.find_one())
3) Execute Python Script

This script prints the inserted record on the console.
4) Enter into Mongo Shell

Now, enter into MongoDB database shell to see the created database and collection.
We can use following command to enter into the database.
1. $ mongo
49
5) Check Databases
The following command is used to show available databases.
1. > show dbs
6) Check Collection
The following command is used to show available collection into the database.
1. > show collections

50
7) Access Records
We can see the stored records in particular collection. The following command is
used to show the record.
1. > db.employees.find()
Python MongoDB
Python can be used in database applications.
One of the most popular NoSQL database is MongoDB.
MongoDB
MongoDB stores data in JSON-like documents, which makes the database
very flexible and scalable.
51
To be able to experiment with the code examples in this tutorial, you will
need access to a MongoDB database.
You can download a free MongoDB database at https://www.mongodb.com.
Or get started right away with a MongoDB cloud service

at https://www.mongodb.com/cloud/atlas.
PyMongo
Python needs a MongoDB driver to access the MongoDB database.
In this tutorial we will use the MongoDB driver "PyMongo".
We recommend that you use PIP to install "PyMongo".
PIP is most likely already installed in your Python environment.
Navigate your command line to the location of PIP, and type the following:
Download and install "PyMongo":
C:\Users\Your Name\AppData\Local\Programs\Python\Python36-32\
Scripts>python -m pip install pymongo
Now you have downloaded and installed a mongoDB driver.
Test PyMongo
To test if the installation was successful, or if you already have "pymongo"
installed, create a Python page with the following content:
demo_mongodb_test.py:
import pymongo
If the above code was executed with no errors, "pymongo" is installed and
ready to be used.
52
Python MongoDB Create Database

Creating a Database
To create a database in MongoDB, start by creating a MongoClient object,
then specify a connection URL with the correct ip address and the name of
the database you want to create.
MongoDB will create the database if it does not exist, and make a connection
to it.
Example
Create a database called "mydatabase":
import pymongo
myclient = pymongo.MongoClient("mongodb://localhost:27017/")
mydb = myclient["mydatabase"]
Important: In MongoDB, a database is not created until it gets content!
MongoDB waits until you have created a collection (table), with at least one
document (record) before it actually creates the database (and collection).
Python MongoDB Insert

Document
A document in MongoDB is the same as a record in SQL databases.
Insert Into Collection

To insert a record, or document as it is called in MongoDB, into a collection,
we use the insert_one() method.
The first parameter of the insert_one() method is a dictionary containing the

name(s) and value(s) of each field in the document you want to insert.
53
Example
Insert a record in the "customers" collection:
import pymongo
mycol = mydb["customers"]
mydict = { "name": "John", "address": "Highway 37" }
x = mycol.insert_one(mydict)
Return the _id Field

The insert_one() method returns a InsertOneResult object, which has a
property, inserted_id, that holds the id of the inserted document.
Example
Insert another record in the "customers" collection, and return the value of
the _id field:
mydict = { "name": "Peter", "address": "Lowstreet 27" }
x = mycol.insert_one(mydict)
print(x.inserted_id)
If you do not specify an _id field, then MongoDB will add one for you and
assign a unique id for each document.
In the example above no _id field was specified, so MongoDB assigned a

unique _id for the record (document).
Insert Multiple Documents

To insert multiple documents into a collection in MongoDB, we use
the insert_many() method.
54
The first parameter of the insert_many() method is a list containing

dictionaries with the data you want to insert:
Example
import pymongo
mylist = [
{ "name": "Amy", "address": "Apple st 652"},
{ "name": "Hannah", "address": "Mountain 21"},
{ "name": "Michael", "address": "Valley 345"},
{ "name": "Sandy", "address": "Ocean blvd 2"},
{ "name": "Betty", "address": "Green Grass 1"},
{ "name": "Richard", "address": "Sky st 331"},
{ "name": "Susan", "address": "One way 98"},
{ "name": "Vicky", "address": "Yellow Garden 2"},
{ "name": "Ben", "address": "Park Lane 38"},
{ "name": "William", "address": "Central st 954"},
{ "name": "Chuck", "address": "Main Road 989"},
{ "name": "Viola", "address": "Sideway 1633"}
]
x = mycol.insert_many(mylist)
#print list of the _id values of the inserted documents:

print(x.inserted_ids)
The insert_many() method returns a InsertManyResult object, which has a

property, inserted_ids, that holds the ids of the inserted documents.
Insert Multiple Documents, with Specified

IDs
If you do not want MongoDB to assign unique ids for you document, you can
specify the _id field when you insert the document(s).
Remember that the values has to be unique. Two documents cannot have
the same _id.
55
Example
import pymongo
mylist = [
{ "_id": 1, "name": "John", "address": "Highway 37"},
{ "_id": 2, "name": "Peter", "address": "Lowstreet 27"},
{ "_id": 3, "name": "Amy", "address": "Apple st 652"},
{ "_id": 4, "name": "Hannah", "address": "Mountain 21"},
{ "_id": 5, "name": "Michael", "address": "Valley 345"},
{ "_id": 6, "name": "Sandy", "address": "Ocean blvd 2"},
{ "_id": 7, "name": "Betty", "address": "Green Grass 1"},
{ "_id": 8, "name": "Richard", "address": "Sky st 331"},
{ "_id": 9, "name": "Susan", "address": "One way 98"},
{ "_id": 10, "name": "Vicky", "address": "Yellow Garden 2"},
{ "_id": 11, "name": "Ben", "address": "Park Lane 38"},
{ "_id": 12, "name": "William", "address": "Central st 954"},
{ "_id": 13, "name": "Chuck", "address": "Main Road 989"},
{ "_id": 14, "name": "Viola", "address": "Sideway 1633"}
]
x = mycol.insert_many(mylist)
#print list of the _id values of the inserted documents:

print(x.inserted_ids)
Python MongoDB Delete

Document
Delete Document
To delete one document, we use the delete_one() method.
The first parameter of the delete_one() method is a query object defining

which document to delete.
56
Note: If the query finds more than one document, only the first occurrence
is deleted.
Example
Delete the document with the address "Mountain 21":
import pymongo
myquery = { "address": "Mountain 21" }
mycol.delete_one(myquery)
Delete Many Documents

To delete more than one document, use the delete_many() method.
The first parameter of the delete_many() method is a query object defining

which documents to delete.
Example
Delete all documents were the address starts with the letter S:
import pymongo
myquery = { "address": {"$regex": "^S"} }
x = mycol.delete_many(myquery)
print(x.deleted_count, " documents deleted.")
Delete All Documents in a Collection

57
To delete all documents in a collection, pass an empty query object to

the delete_many() method:
Example
Delete all documents in the "customers" collection:
import pymongo
x = mycol.delete_many({})
print(x.deleted_count, " documents deleted.")
Python MongoDB Query

Filter the Result
When finding documents in a collection, you can filter the result by using a
query object.
The first argument of the find() method is a query object, and is used to limit
the search.
Example
Find document(s) with the address "Park Lane 38":
import pymongo
myquery = { "address": "Park Lane 38" }
mydoc = mycol.find(myquery)
for x in mydoc:
print(x)
58
Run example »
Advanced Query
To make advanced queries you can use modifiers as values in the query
object.
E.g. to find the documents where the "address" field starts with the letter "S"
or higher (alphabetically), use the greater than modifier: {"$gt": "S"}:
Example
Find documents where the address starts with the letter "S" or higher:
import pymongo
myquery = { "address": { "$gt": "S" } }
for x in mydoc:
print(x)
Run example »
Filter With Regular Expressions

You can also use regular expressions as a modifier.
Regular expressions can only be used to query strings.
To find only the documents where the "address" field starts with the letter
"S", use the regular expression {"$regex": "^S"}:
Example
Find documents where the address starts with the letter "S":
59
import pymongo
myquery = { "address": { "$regex": "^S" } }
for x in mydoc:
print(x)
Run example »
Check if Database Exists

Remember: In MongoDB, a database is not created until it gets content, so
if this is your first time creating a database, you should complete the next
two chapters (create collection and create document) before you check if the
database exists!
You can check if a database exist by listing all databases in you system:
Example
Return a list of your system's databases:
print(myclient.list_database_names())
Run example »
Or you can check a specific database by name:
Example
Check if "mydatabase" exists:
dblist = myclient.list_database_names()
if "mydatabase" in dblist:
print("The database exists.")
60
Python MongoDB Update

❮ PreviousNext ❯
Update Collection
You can update a record, or document as it is called in MongoDB, by using
the update_one() method.
The first parameter of the update_one() method is a query object defining

which document to update.
Note: If the query finds more than one record, only the first occurrence is
updated.
The second parameter is an object defining the new values of the document.
Example
Change the address from "Valley 345" to "Canyon 123":
import pymongo
myquery = { "address": "Valley 345" }

newvalues = { "$set": { "address": "Canyon 123" } }
mycol.update_one(myquery, newvalues)
#print "customers" after the update:

for x in mycol.find():
print(x)
Run example »
61
Update Many
To update all documents that meets the criteria of the query, use
the update_many() method.
Example
Update all documents where the address starts with the letter "S":
import pymongo
myquery = { "address": { "$regex": "^S" } }

newvalues = { "$set": { "name": "Minnie" } }
x = mycol.update_many(myquery, newvalues)
print(x.modified_count, "documents updated.")
Python MongoDB Drop Collection

Delete Collection
You can delete a table, or collection as it is called in MongoDB, by using
the drop() method.
Example
Delete the "customers" collection:
import pymongo
mycol.drop()
62
Python MongoDB Limit

Limit the Result
To limit the result in MongoDB, we use the limit() method.
The limit() method takes one parameter, a number defining how many
documents to return.
Consider you have a "customers" collection:
Customers
{'_id': 1, 'name': 'John', 'address': 'Highway37'}
{'_id': 2, 'name': 'Peter', 'address': 'Lowstreet 27'}
{'_id': 3, 'name': 'Amy', 'address': 'Apple st 652'}
{'_id': 4, 'name': 'Hannah', 'address': 'Mountain 21'}
{'_id': 5, 'name': 'Michael', 'address': 'Valley 345'}
{'_id': 6, 'name': 'Sandy', 'address': 'Ocean blvd 2'}
{'_id': 7, 'name': 'Betty', 'address': 'Green Grass 1'}
{'_id': 8, 'name': 'Richard', 'address': 'Sky st 331'}
{'_id': 9, 'name': 'Susan', 'address': 'One way 98'}
{'_id': 10, 'name': 'Vicky', 'address': 'Yellow Garden 2'}
{'_id': 11, 'name': 'Ben', 'address': 'Park Lane 38'}
{'_id': 12, 'name': 'William', 'address': 'Central st 954'}
{'_id': 13, 'name': 'Chuck', 'address': 'Main Road 989'}
{'_id': 14, 'name': 'Viola', 'address': 'Sideway 1633'}
Example
Limit the result to only return 5 documents:
import pymongo
myresult = mycol.find().limit(5)
#print the result:

for x in myresult:
print(x)
63
Python - GUI Programming (Tkinter)

Python provides various options for developing graphical user interfaces (GUIs).
Most important are listed below.
 Tkinter − Tkinter is the Python interface to the Tk GUI toolkit shipped with
Python. We would look this option in this chapter.
 wxPython − This is an open-source Python interface for
wxWindows http://wxpython.org.
 JPython − JPython is a Python port for Java which gives Python scripts
seamless access to Java class libraries on the local
machine http://www.jython.org.
There are many other interfaces available, which you can find them on the net.
Tkinter Programming
64
Tkinter is the standard GUI library for Python. Python when combined with Tkinter
provides a fast and easy way to create GUI applications. Tkinter provides a
powerful object-oriented interface to the Tk GUI toolkit.
Creating a GUI application using Tkinter is an easy task. All you need to do is
perform the following steps −
 Import the Tkinter module.
 Create the GUI application main window.
 Add one or more of the above-mentioned widgets to the GUI application.
 Enter the main event loop to take action against each event triggered by the
user.
Example
#!/usr/bin/python
import Tkinter
top = Tkinter.Tk()
# Code to add widgets will go here...
top.mainloop()
This would create a following window −
Tkinter Widgets
Tkinter provides various controls, such as buttons, labels and text boxes used in a
GUI application. These controls are commonly called widgets.
There are currently 15 types of widgets in Tkinter. We present these widgets as well
as a brief description in the following table −
65
Python Tkinter Tutorial
Tkinter tutorial provides basic and advanced concepts of Python Tkinter. Our Tkinter
tutorial is designed for beginners and professionals.
Python provides the standard library Tkinter for creating the graphical user interface
for desktop based applications.
Developing desktop based applications with python Tkinter is not a complex task. An
empty Tkinter top-level window can be created by using the following steps.
1. import the Tkinter module.
2. Create the main application window.
3. Add the widgets like labels, buttons, frames, etc. to the window.
4. Call the main event loop so that the actions can take place on the user's
computer screen.
Example
1. # !/usr/bin/python3
2. from tkinter import *
3. #creating the application main window.
4. top = Tk()
5. #Entering the event main loop
6. top.mainloop()
7. here are various widgets like button, canvas, checkbutton, entry, etc. that are
used to build the python GUI applications.
SN Widget Description
1 Button The Button is used to add various kinds of buttons to

the python application.
66
2 Canvas The canvas widget is used to draw the canvas on the

window.
3 Checkbutton The Checkbutton is used to display the CheckButton

on the window.
4 Entry The entry widget is used to display the single-line

text field to the user. It is commonly used to accept
user values.
5 Frame It can be defined as a container to which, another

widget can be added and organized.
6 Label A label is a text used to display some message or

information about the other widgets.
7 ListBox The ListBox widget is used to display a list of options

to the user.
8 Menubutton The Menubutton is used to display the menu items to

the user.
9 Menu It is used to add menu items to the user.
10 Message The Message widget is used to display the message-

box to the user.
11 Radiobutton The Radiobutton is different from a checkbutton.

Here, the user is provided with various options and
the user can select only one option among them.
12 Scale It is used to provide the slider to the user.
13 Scrollbar It provides the scrollbar to the user so that the user

can scroll the window up and down.
14 Text It is different from Entry because it provides a multi-

line text field to the user so that the user can write
the text and edit the text inside it.
67
14 Toplevel It is used to create a separate window container.
15 Spinbox It is an entry widget used to select from options of

values.
16 PanedWindow It is like a container widget that contains horizontal

or vertical panes.
17 LabelFrame A LabelFrame is a container widget that acts as the

container
18 MessageBox This module is used to display the message-box in

the desktop based applications.
Python Tkinter Geometry

The Tkinter geometry specifies the method by using which, the widgets are
represented on display. The python Tkinter provides the following geometry
methods.
1. The pack() method
2. The grid() method
3. The place() method
Let's discuss each one of them in detail.
Python Tkinter pack() method

The pack() widget is used to organize widget in the block. The positions widgets
added to the python application using the pack() method can be controlled by using
the various options specified in the method call.
However, the controls are less and widgets are generally added in the less organized
manner.
The syntax to use the pack() is given below.
syntax
1. widget.pack(options)
A list of possible options that can be passed in pack() is given below.

68
o expand: If the expand is set to true, the widget expands to fill any space.
o Fill: By default, the fill is set to NONE. However, we can set it to X or Y to

determine whether the widget contains any extra space.
o size: it represents the side of the parent to which the widget is to be placed
on the window.
Example
3. parent = Tk()
4. redbutton = Button(parent, text = "Red", fg = "red")
5. redbutton.pack( side = LEFT)
6. greenbutton = Button(parent, text = "Black", fg = "black")
7. greenbutton.pack( side = RIGHT )
8. bluebutton = Button(parent, text = "Blue", fg = "blue")
9. bluebutton.pack( side = TOP )
10.blackbutton = Button(parent, text = "Green", fg = "red")
11.blackbutton.pack( side = BOTTOM)
12.parent.mainloop()
Output:
Python Tkinter grid() method

The grid() geometry manager organizes the widgets in the tabular form. We can
specify the rows and columns as the options in the method call. We can also specify
the column span (width) or rowspan(height) of a widget.
This is a more organized way to place the widgets to the python application. The
syntax to use the grid() is given below.
Syntax
1. widget.grid(options)
A list of possible options that can be passed inside the grid() method is given below.
69
o Column
The column number in which the widget is to be placed. The leftmost column
is represented by 0.
o Columnspan
The width of the widget. It represents the number of columns up to which,
the column is expanded.
o ipadx, ipady
It represents the number of pixels to pad the widget inside the widget's
border.
o padx, pady
It represents the number of pixels to pad the widget outside the widget's
border.
o row
The row number in which the widget is to be placed. The topmost row is
represented by 0.
o rowspan
The height of the widget, i.e. the number of the row up to which the widget is
expanded.
o Sticky
If the cell is larger than a widget, then sticky is used to specify the position of
the widget inside the cell. It may be the concatenation of the sticky letters
representing the position of the widget. It may be N, E, W, S, NE, NW, NS,
EW, ES.
Example
3. parent = Tk()
4. name = Label(parent,text = "Name").grid(row = 0, column = 0)
5. e1 = Entry(parent).grid(row = 0, column = 1)
6. password = Label(parent,text = "Password").grid(row = 1, column = 0)
7. e2 = Entry(parent).grid(row = 1, column = 1)
8. submit = Button(parent, text = "Submit").grid(row = 4, column = 0)
9. parent.mainloop()
Output:
70
Python Tkinter place() method

The place() geometry manager organizes the widgets to the specific x and y
coordinates.
Syntax
1. widget.place(options)
A list of possible options is given below.
o Anchor: It represents the exact position of the widget within the container.
The default value (direction) is NW (the upper left corner)
o bordermode: The default value of the border type is INSIDE that refers to
ignore the parent's inside the border. The other option is OUTSIDE.
o height, width: It refers to the height and width in pixels.
o relheight, relwidth: It is represented as the float between 0.0 and 1.0

indicating the fraction of the parent's height and width.
o relx, rely: It is represented as the float between 0.0 and 1.0 that is the
offset in the horizontal and vertical direction.
o x, y: It refers to the horizontal and vertical offset in the pixels.
Example
3. top = Tk()
4. top.geometry("400x250")
5. name = Label(top, text = "Name").place(x = 30,y = 50)
6. email = Label(top, text = "Email").place(x = 30, y = 90)
7. password = Label(top, text = "Password").place(x = 30, y = 130)
8. e1 = Entry(top).place(x = 80, y = 50)
9. e2 = Entry(top).place(x = 80, y = 90)
10.e3 = Entry(top).place(x = 95, y = 130)
11.top.mainloop()
71
Python Tkinter Button

The button widget is used to add various types of buttons to the python application.
Python allows us to configure the look of the button according to our requirements.
Various options can be set or reset depending upon the requirements.
We can also associate a method or function with a button which is called when the
button is pressed.
The syntax to use the button widget is given below.
Syntax
1. W = Button(parent, options)
A list of possible options is given below.
SN Option Description
1 activebackgroun It represents the background of the button when the mouse hove
d
2 activeforeground It represents the font color of the button when the mouse hover
3 Bd It represents the border width in pixels.
4 Bg It represents the background color of the button.
5 Command It is set to the function call which is scheduled when the function
6 Fg Foreground color of the button.
7 Font The font of the button text.
8 Height The height of the button. The height is represented in the numbe
pixels for the images.
10 Highlightcolor The color of the highlight when the button has the focus.
72
11 Image It is set to the image displayed on the button.
12 justify It illustrates the way by which the multiple text lines are represe
the right justification, and CENTER for the center.
13 Padx Additional padding to the button in the horizontal direction.
14 pady Additional padding to the button in the vertical direction.
15 Relief It represents the type of the border. It can be SUNKEN, RAISED,
17 State This option is set to DISABLED to make the button unresponsive.

button.
18 Underline Set this option to make the button text underlined.
19 Width The width of the button. It exists as a number of letters for textu
20 Wraplength If the value is set to a positive number, the text lines will be wra
Example
1. #python application to create a simple button
2.
4.
5.
6. top = Tk()
7.
9.
10.b = Button(top,text = "Simple")
11.
12.b.pack()
13.
14.top.mainaloop()
73
Output:
Python Tkinter Canvas

The canvas widget is used to add the structured graphics to the python application.
It is used to draw the graph and plots to the python application. The syntax to use
the canvas is given below.
Syntax
1. w = canvas(parent, options)
3.
4. top = Tk()
5.
7.
8. #creating a simple canvas
9. c = Canvas(top,bg = "pink",height = "200")
10.
11.
12.c.pack()
13.
14.top.mainloop()
Example: Creating an arc

2.
3. top = Tk()
4.
6.
7. #creating a simple canvas
74
8. c = Canvas(top,bg = "pink",height = "200",width = 200)

9.
10.arc = c.create_arc((5,10,150,200),start = 0,extent = 150, fill= "white")
11.
12.c.pack()
13.
14.top.mainloop()
Python Tkinter Checkbutton

The Checkbutton is used to track the user's choices provided to the application. In
other words, we can say that Checkbutton is used to implement the on/off
selections.
The Checkbutton can contain the text or images. The Checkbutton is mostly used to
provide many choices to the user among which, the user needs to choose the one. It
generally implements many of many selections.
The syntax to use the checkbutton is given below.
Example
2.
3. top = Tk()
4.
6.
7. checkvar1 = IntVar()
8.
9. checkvar2 = IntVar()
10.
11.checkvar3 = IntVar()
12.
13.chkbtn1 = Checkbutton(top, text = "C", variable = checkvar1, onvalue = 1, o
ffvalue = 0, height = 2, width = 10)
14.
15.chkbtn2 = Checkbutton(top, text = "C++", variable = checkvar2, onvalue =
1, offvalue = 0, height = 2, width = 10)
16.
75
17.chkbtn3 = Checkbutton(top, text = "Java", variable = checkvar3, onvalue = 1

, offvalue = 0, height = 2, width = 10)
18.
19.chkbtn1.pack()
20.
21.chkbtn2.pack()
22.
23.chkbtn3.pack()
24.
25.top.mainloop()
Python Tkinter Entry

The Entry widget is used to provde the single line text-box to the user to accept a
value from the user. We can use the Entry widget to accept the text strings from the
user. It can only be used for one line of text from the user. For multiple lines of text,
we must use the text widget.
The syntax to use the Entry widget is given below.
Syntax
1. w = Entry (parent, options)
Example
2.
4.
5. top = Tk()
6.
8.
9. name = Label(top, text = "Name").place(x = 30,y = 50)
10.
11.email = Label(top, text = "Email").place(x = 30, y = 90)
12.
13.password = Label(top, text = "Password").place(x = 30, y = 130)
14.
15.sbmitbtn = Button(top, text = "Submit",activebackground = "pink", activefor
eground = "blue").place(x = 30, y = 170)
76
16.
18.
19.
21.
22.
24.
25.top.mainloop()
Python Tkinter Frame

Python Tkinter Frame widget is used to organize the group of widgets. It acts like a
container which can be used to hold the other widgets. The rectangular areas of the
screen are used to organize the widgets to the python application.
The syntax to use the Frame widget is given below.
Syntax
1. w = Frame(parent, options)
Example
2.
3. top = Tk()
5. frame = Frame(top)
6. frame.pack()
7.
8. leftframe = Frame(top)
9. leftframe.pack(side = LEFT)
10.
11.rightframe = Frame(top)
12.rightframe.pack(side = RIGHT)
13.
14.btn1 = Button(frame, text="Submit", fg="red",activebackground = "red")
15.btn1.pack(side = LEFT)
16.
77
17.btn2 = Button(frame, text="Remove", fg="brown", activebackground = "bro

wn")
18.btn2.pack(side = RIGHT)
19.
20.btn3 = Button(rightframe, text="Add", fg="blue", activebackground = "blue")
21.btn3.pack(side = LEFT)
22.
23.btn4 = Button(leftframe, text="Modify", fg="black", activebackground = "whi
te")
24.btn4.pack(side = RIGHT)
25.
26.top.mainloop()
Next →← Prev
Python Tkinter Label

The Label is used to specify the container box where we can place the text or
images. This widget is used to provide the message to the user about other
widgets used in the python application.
There are the various options which can be specified to configure the text or the
part of the text shown in the Label.
The syntax to use the Label is given below.
Syntax
1. w = Label (master, options)
Example 1
2.
4.
5. top = Tk()
6.
8.
78
9. #creating label
10.uname = Label(top, text = "Username").place(x = 30,y = 50)
11.
12.#creating label
13.password = Label(top, text = "Password").place(x = 30, y = 90)
14.
15.
16.sbmitbtn = Button(top, text = "Submit",activebackground = "pink", activefor
eground = "blue").place(x = 30, y = 120)
17.
18.e1 = Entry(top,width = 20).place(x = 100, y = 50)
19.
20.
21.e2 = Entry(top, width = 20).place(x = 100, y = 90)
22.
23.
24.top.mainloop()
Standard attributes
Let us take a look at how some of their common attributes.such as sizes, colors and
fonts are specified.
 Dimensions
 Colors
 Fonts
 Anchors
 Relief styles
 Bitmaps
 Cursors
Let us study them briefly −
Geometry Management
All Tkinter widgets have access to specific geometry management methods, which
have the purpose of organizing widgets throughout the parent widget area. Tkinter
exposes the following geometry manager classes: pack, grid, and place.
 The pack() Method − This geometry manager organizes widgets in blocks
before placing them in the parent widget.
 The grid() Method − This geometry manager organizes widgets in a table-like
structure in the parent widget.
79
 The place() Method − This geometry manager organizes widgets by placing

them in a specific position in the parent widget.
Let us study the geometry management methods briefly −
Python Tkinter Text

The Text widget is used to show the text data on the Python application. However,
Tkinter provides us the Entry widget which is used to implement the single line text
box.
The Text widget is used to display the multi-line formatted text with various styles
and attributes. The Text widget is mostly used to provide the text editor to the user.
The Text widget also facilitates us to use the marks and tabs to locate the specific
sections of the Text. We can also use the windows and images with the Text as it
can also be used to display the formatted text.
The syntax to use the Text widget is given below.
Syntax
1. w = Text(top, options)
Example
2.
3. top = Tk()
4. text = Text(top)
5. text.insert(INSERT, "Name.....")
6. text.insert(END, "Salary.....")
7.
8. text.pack()
9.
10.text.tag_add("Write Here", "1.0", "1.4")
11.text.tag_add("Click Here", "1.8", "1.13")
12.
13.text.tag_config("Write Here", background="yellow", foreground="black")
14.text.tag_config("Click Here", background="black", foreground="white")
15.
16.top.mainloop()
80
Tkinter messagebox
The messagebox module is used to display the message boxes in the python
applications. There are the various functions which are used to display the relevant
messages depending upon the application requirements.
The syntax to use the messagebox is given below.
Syntax
1. messagebox.function_name(title, message [, options])
Parameters
o function_name: It represents an appropriate message box function.
o title: It is a string which is shown as a title of a message box.
o message: It is the string to be displayed as a message on the message box.
o options: There are various options which can be used to configure the
message dialog box.
The two options that can be used are default and parent.
1. default
The default option is used to mention the types of the default button, i.e. ABORT,
RETRY, or IGNORE in the message box.
2. parent
The parent option specifies the parent window on top of which, the message box is
to be displayed.
There is one of the following functions used to show the appropriate message boxes.
All the functions are used with the same syntax but have the specific functionalities.
1. showinfo()
The showinfo() messagebox is used where we need to show some relevant
information to the user.
Example
2.
4.
5. from tkinter import messagebox
81
6.
7. top = Tk()
8.
10.
11.messagebox.showinfo("information","Information")
12.
13.top.mainloop()
Output:
2. showwarning()
This method is used to display the warning to the user. Consider the following
example.
Example
3.
5.
6. top = Tk()
8. messagebox.showwarning("warning","Warning")
9.
10.top.mainloop()
Output:
82
3. showerror()
This method is used to display the error message to the user. Consider the following
example.
Example
4.
5. top = Tk()
7. messagebox.showerror("error","Error")
8. top.mainloop()
Output:
4. askquestion()
This method is used to ask some question to the user which can be answered in yes
or no. Consider the following example.
Example
83

4.
5. top = Tk()
7. messagebox.askquestion("Confirm","Are you sure?")
8. top.mainloop()
Output:
5. askokcancel()
This method is used to confirm the user's action regarding some application activity.
Example
4.
5. top = Tk()
7. messagebox.askokcancel("Redirect","Redirecting you to www.javatpoint.com"
)
8. top.mainloop()
Output:
84
6. askyesno()
This method is used to ask the user about some action to which, the user can
answer in yes or no. Consider the following example.
Example
4.
5. top = Tk()
7. messagebox.askyesno("Application","Got It?")
8. top.mainloop()
Output:
7. askretrycancel()
This method is used to ask the user about doing a particular task again or not.
Example
85

4.
5. top = Tk()
7. messagebox.askretrycancel("Application","try again?")
8.
9. top.mainloop()
Output:

Python Decorators

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Python Decorators

Uploaded by

Copyright:

Available Formats

1

# Python program to illustrate functions

What are the functions in Python?

We are in first function

A function can return another function. Consider the below example:

'''Above code is equivalent to -

# inner1 is a Wrapper function in

# inner function can access the outer local

# calling the actual function now

print("This is after function execution")

# defining a function, to be called inside wrapper

# passing 'function_to_be_used' inside the

# calling the function

We can import mod_decorator.py in other file.

1. from decorator import do_twice

Python Decorator with Argument

1. from decorator import do_twice

TypeError: display() missing 1 required positional argument: 'name'

1. from decorator import do_twice

Returning Values from Decorated Functions

1. from decorator import do_twice

We are created greeting

Example:2 - @staticmethod decorator- The @staticmethod is used to define a

Decorator with Arguments

It is always useful to pass arguments in a decorator. The decorator can be executed

10. value = func(*args,**kwargs)

Note: Decorator with argument is not frequently used in programming, but it

To making a class callable, we implement the special __call__() method.

9. def __call__(self, *args, **kwargs):

There is a lot of complexity in creating iteration in Python; we need to

It is a lengthy process to create iterators. That's why the generator plays an

How to Create Generator function in

yield vs. return

Using multiple yield Statement

Difference between Generator function and Normal

o StopIteration exception is raised automatically when the function terminates.

There is a lot of complexity in creating iteration in Python; we need to

It is a lengthy process to create iterators. That's why the generator plays an

How to Create Generator function in

yield vs. return

Using multiple yield Statement

Difference between Generator function and

o StopIteration exception is raised automatically when the function

We can easily create a generator expression without using user-defined function.

The representation of generator expression is similar to the Python list

Consider the following example:

<generator object <genexpr> at 0x01BA3CD8>

Execute the following command to install it using pip installer.

1. > python -m pip install mysql-connector

Or follow the following steps.

1. Click the link:

2. Extract the archived file.

1. $ python setup.py build

5. Run the following command to install the mysql-connector.

1. $ python setup.py install

Hence, we have successfully installed mysql-connector for python on our system.

1. Import mysql.connector module

2. Create the connection object.

3. Create the cursor object

4. Execute the query

Creating the connection

The syntax to use the connect() is given below.

1. Connection-Object= mysql.connector.connect(host = <host-name> , user =

Consider the following example.

To making a class callable, we implement the special call() method.

9. def call(self, *args, **kwargs):