Scribd
Upload
48 views

Chapter 10 - Interface Python With MySQL

The document discusses how to connect a Python application to a MySQL database. It outlines the 7 main steps: 1) start Python, 2) import mysql.connector package, 3) open a connection, 4) create a cursor, 5) execute queries, 6) extract data, and 7) close the connection. Key aspects covered include connecting to the database, executing queries, retrieving result sets using fetch functions, parameterizing queries, and performing insert and update operations.

Uploaded by

Jess
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
48 views

Chapter 10 - Interface Python With MySQL

The document discusses how to connect a Python application to a MySQL database. It outlines the 7 main steps: 1) start Python, 2) import mysql.connector package, 3) open a connection, 4) create a cursor, 5) execute queries, 6) extract data, and 7) close the connection. Key aspects covered include connecting to the database, executing queries, retrieving result sets using fetch functions, parameterizing queries, and performing insert and update operations.

Uploaded by

Jess
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 7

Chapter 10 – Interface Python with MySQL

In order to connect to a database from within Python, you need a library(mysql connector) that
provides connectivity functionality.

Steps for Creating Database Connectivity Applications

There are mainly seven steps that must be followed in order to create a database connectivity
application.

Step 1 : Start Python.


Step 2 : Import the packages required for database programming.
Step 3 : Open a connection to database.
Step 4 : Create a cursor instance.
Step 5 : Execute a query.
Step 6 : Extract data from result set.
Step 7 : Clean up the environment.

Step 1. Start Python

- Start Python’s editor where you can create your Python scripts.
Step 2. Import mysql.connector Package

- First of all you need to import mysql.connector package in your Python scripts. For this, write
import command as shown below:

import mysql.connector

or
import mysql.connector as sqLtor

Step 3: Open a connection to database.

- The connect( ) function of mysql.connector establishes connection to a MySQL database and


requires four parameters, which are:

<connection-object> = mysql.connector.connect(host = <host-name> , user = <username> ,


passwd = <password> , database = <database>)
e.g.

The above command will establish connection to MySQL database with user as “root” , password
as “MyPass” and to the MySQL database namely test which exists on the MySQL.

P a g e 1|7
- You can also check for successful connection using function is_connected( ) with connected
object, which returns True , if connection is successful.
e.g.

Step 4 : Create a cursor instance.


- When we connect to a database from within a script/program, then the query gets sent to the
server, where it gets executed, and the resultset (the set of records retrieved as per query) is sent
over the connection to you, in one burst of activity, i.e. in one go. And in order to do the processing
of data row by row, a special control structure is used, which is called Database Cursor.
- Syntax:
<cursorobject> = <connectedobject>.cursor( )
- E.g.

Step 5 : Execute a query


- Once you have created a cursor, you can execute SQL query using execute( ) function with cursor
object as per following syntax:
<cursorobject>.execute(<sql query string>)

- E.g.

The above code will execute the given SQL query and store the retrieved records(i.e. , the resultset)
in the cursor object (namely cursor) which you can then use in your program/scripts as required.

Step 6 : Extract data from result set.


- Once the result of query is available in the form of a resultset stored in a cursor object, you can
extract data from the resultset using any of the following fetch( ) functions.
(i) <data>= <cursor>.fetchall( ) - It will return all the records retrieved as per query in a tuple
form.
(ii) <data> = <cursor>.fetchone( ) - It will return one record from the resultset as a tuple or a
list. First time it will return the first record, next time it will fetch the next record and so
on.
This method returns one record as a tuple : if there are no more records then it returns
None.

P a g e 2|7
(iii) <data>=<cursor>.fetchmany(<n>) - This method accepts number of records to fetch and
returns a tuple where each record itself is a tuple.
(iv) <variable>=<cursor>.rowcount – The rowcount is a property of cursor object that returns
the number of rows retrieved from the cursor so far.
For Example,

(i) The fetchall( ) method

P a g e 3|7
(ii) The fetchmany( ) method

(iii) The fetchone( ) method

P a g e 4|7
Step 7: Clean up the Environment

- In this final step, you need to close the connection established. This you can do as follows:
<connection object>.close( )
- E.g.
mycon.close( )

Parameterised Queries

E.g.

Two methods to form query strings based on some parameters:

(i) Old Style : String Templates with % formatting


- In this style, string formatting uses this general form : f % v
Where f is a template string and v specifies the value or values to be formatted using that
template.

e.g.

Now you can store this query string in variable and then execute that variable through
cursor.execute( ) method as shown below :

P a g e 5|7
- In the similar manner, you can add multiple parameter values, but you must not forget to enclose
placeholder %s in quotes for string parameters e.g.

(ii) New Style : String Templates with % formatting


- This method is based on use of format( ) method.
- The general form for using format( ) is :
template.format(p0 , p1 , …….., k0 = v0 , k1 = v1, …….. )
The template is a string containing a mixture of one or more format codes embedded in constant
text. The format method uses its argument to substitute an appropriate value for each format
code in the template.

e.g.1.

e.g.2.

Output:

e.g.3.

P a g e 6|7
Performing INSERT and UPDATE Queries

- Insert and Update SQL commands, can also executed using SELECT queries.
- But after executing INSERT and UPDATE queries you must commit your query. This makes the
changes made by the INSERT and UPDATE queries permanent. For this you must run commit( )
method , i.e.
<connection object>.commit( )

E.g. 1. INSERT query example


st = “INSERT INTO student (rollno , name , marks , marks , grade, section)
VALUES({ } , ‘{ }’ , { } , ‘{ }’, ‘{ }’ )”.format( 108,’Eka’ , 84.0 , ‘A’ , ‘B’)
cursor.execute(st)
mycon.commit( )

E.g. 2. UPDATE query example


st = “UPDATE student SET marks = { } WHERE marks = { }” . format(77, 76.8)
cursor.execute(st)
mycon.commit( )

Important Questions
Q1. What is database connectivity ?
Ans. Database connectivity refers to connection and communication between an application and a
database system.
Q2. What is Connection ? What is its role?
Ans. A Connection (represented through a connection object) is the session between the application
program and a database. To do anything with database, one must have a connection object.
Q3. What is a result set?
Ans. A result set refers to a logical set of records that are fetched from the database by executing a
query and made available to the application-program.
Q4. Which package must be imported in Python to create a database connectivity application?
Ans. One such package is mysql.connector

*************************

P a g e 7|7

You might also like