Python Tutorial: How to Connect to SQL Server in Python


Python is a powerful programming language that is widely used in various industries, including data science, web development, and automation. One of the key strengths of Python is its ability to connect to various databases, including SQL Server. In this tutorial, we will explore how to connect to SQL Server in Python.

Before we dive into the code, let’s briefly discuss what SQL Server is and why it is important. SQL Server is a relational database management system (RDBMS) developed by Microsoft that stores and retrieves data for various applications. It is widely used in enterprise environments due to its scalability, security features, and robustness.

Python provides several libraries for connecting to SQL Server, including pyodbc and pymssql. These libraries allow Python developers to interact with SQL Server databases by sending queries and receiving results.

In the next sections of this tutorial, we will explore how to install these libraries and use them to connect to SQL Server in Python. We will also cover some common tasks such as querying data and updating records. So let’s get started!

Table of Contents

Step 2: Import pyodbc Module

To connect to SQL Server using Python, we need to use a module called pyodbc. This module provides an interface between Python and Microsoft SQL Server, allowing us to execute SQL statements and retrieve data from the database.

To import the pyodbc module, we first need to install it. We can do this using pip, which is a package manager for Python. Open your command prompt or terminal and run the following command:

pip install pyodbc

Once you have installed pyodbc, you can import it into your Python script using the following code:

import pyodbc

This will make all of the functions and classes provided by the pyodbc module available in your script.

Now that we have imported the pyodbc module, we can move on to establishing a connection to our SQL Server instance.

Step 3: Establish Connection to SQL Server

Now that we have installed the necessary libraries and have the server credentials, we can establish a connection to our SQL Server using Python. We will be using the pyodbc library to connect to our SQL Server.

Here’s an example code snippet that shows how to establish a connection:

import pyodbc 

server = 'your_server_name'
database = 'your_database_name'
username = 'your_username'
password = 'your_password'

# Establishing a connection to the SQL Server
cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};\
                      PWD='+ password)

cursor = cnxn.cursor()

In this example, we imported the `pyodbc` library and defined our server name, database name, username, and password. Then, we used the `connect()` method from `pyodbc` to establish a connection to the SQL Server by passing in the necessary parameters.

Once we have established a connection, we create a cursor object using `cnxn.cursor()`. The cursor object allows us to execute SQL statements on our server.

Note that the specific driver you use may differ depending on your system configuration. You can find out which driver you need by checking your ODBC Data Source Administrator.

In summary, establishing a connection to SQL Server using Python is fairly straightforward with the help of the `pyodbc` library. Once we have established a connection and created a cursor object, we can execute SQL statements on our server.

Step 4: Create Cursor Object and Execute SQL Queries

After establishing a connection to the SQL Server in Python, the next step is to create a cursor object. A cursor object allows you to execute SQL queries against the database and retrieve data.

To create a cursor object, you can use the `cursor()` method of the connection object. Here’s an example:

cursor = conn.cursor()

Once you have a cursor object, you can use it to execute SQL queries by calling its `execute()` method. The `execute()` method takes an SQL query as an argument and executes it against the database. Here’s an example:

query = "SELECT * FROM employees"

In this example, we are executing a simple SELECT query that retrieves all rows from the `employees` table. Note that we are passing the query as a string to the `execute()` method.

After executing a query, you can retrieve the results using one of the fetch methods of the cursor object. The most common fetch methods are `fetchone()`, which retrieves one row at a time, and `fetchall()`, which retrieves all rows at once. Here’s an example:

# Fetch one row at a time
row = cursor.fetchone()
while row:
    row = cursor.fetchone()

# Fetch all rows at once
rows = cursor.fetchall()
for row in rows:

In this example, we first use a while loop and the `fetchone()` method to retrieve one row at a time and print it. We keep looping until there are no more rows to fetch. Then, we use the `fetchall()` method to retrieve all rows at once and print them using a for loop.

It’s important to note that after executing a query, you should always close the cursor object using its `close()` method:


Closing the cursor releases any resources that it was holding, such as locks on the database. It also frees up memory on the client side.

Step 5: Retrieve Data from SQL Server

Now that we have successfully connected to the SQL Server database, we can retrieve data from it using Python. There are several ways to retrieve data from SQL Server in Python, but we will be using the `pandas` library for this tutorial.

`pandas` is a popular data manipulation library that provides data structures for efficiently storing and analyzing large datasets. It also has built-in functions for reading and writing data to various file formats, including SQL databases.

To retrieve data from SQL Server using `pandas`, we first need to write a SQL query that specifies which data we want to extract. We can then use the `read_sql_query()` function from `pandas` to execute the query and store the results in a `DataFrame`.

Here’s an example of how to retrieve all records from a table called `employees` in our SQL Server database:

import pandas as pd
import pyodbc

# Set up connection
cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=localhost;DATABASE=mydatabase;UID=username;PWD=password')

# Define SQL query
query = 'SELECT * FROM employees'

# Execute query and store results in a DataFrame
df = pd.read_sql_query(query, cnxn)

# Print first few rows of DataFrame

In this example, we first import the necessary libraries (`pandas` and `pyodbc`) and set up the database connection using the same parameters as in Step 4.

Next, we define our SQL query as a string variable called `query`. This query simply selects all columns (`*`) from the `employees` table.

We then use the `pd.read_sql_query()` function to execute the query and store the results in a DataFrame called `df`. This function takes two arguments: the SQL query and the database connection object (`cnxn`).

Finally, we print out the first few rows of the DataFrame using the `head()` function to verify that we have successfully retrieved the data.

Of course, this is just a simple example. You can modify the SQL query to retrieve specific columns or filter the data using conditions. Once you have the data in a DataFrame, you can use all the powerful data manipulation and analysis functions provided by `pandas`.

Step 6: Close Connection to SQL Server

After we have executed our queries and retrieved the necessary data from the SQL Server, it is important to close the connection to the server. This is done using the `close()` method of the connection object.

Here’s an example:

import pyodbc

# Establishing a connection to SQL Server
connection = pyodbc.connect('Driver={SQL Server};'

# Creating a cursor object
cursor = connection.cursor()

# Executing SQL queries
cursor.execute('SELECT * FROM table_name')
data = cursor.fetchall()

# Closing the connection

In the above example, we have established a connection to the SQL Server, created a cursor object, executed a SQL query, retrieved the data using `fetchall()` method, and finally closed the connection using the `close()` method.

It is important to close the connection after we are done with our work as it releases any resources that were being used by our program. Leaving connections open can also cause issues with other applications trying to access the same server.

Closing the connection to SQL Server should always be done after executing queries and retrieving data. This ensures that our program runs efficiently and does not cause any issues for other applications accessing the same server.


In this tutorial, we have learned how to use Python to connect to SQL Server. We started by installing the necessary packages and libraries such as pyodbc and pandas. We then created a connection string with the required credentials to establish a connection between our Python code and SQL Server.

After establishing the connection, we executed SQL queries using the execute() method of the cursor object in pyodbc. We also saw how to retrieve data from the database using fetchall() and fetchone() methods.

We also explored how to use pandas library to read data from SQL Server into a pandas DataFrame, which can be further manipulated and analyzed using pandas functions.

It is important to note that connecting to a database requires proper access credentials and permissions. It is recommended to keep these credentials secure and not hardcode them in your Python code.

Overall, Python provides a powerful and flexible way for data professionals to connect to SQL Server databases and perform various data manipulation tasks. With this tutorial, you should now be able to connect to SQL Server databases in Python and start exploring your data using the power of Python.
Interested in learning more? Check out our Introduction to Python course!

How to Become a Data Scientist PDF

Your FREE Guide to Become a Data Scientist

Discover the path to becoming a data scientist with our comprehensive FREE guide! Unlock your potential in this in-demand field and access valuable resources to kickstart your journey.

Don’t wait, download now and transform your career!

Pierian Training
Pierian Training
Pierian Training is a leading provider of high-quality technology training, with a focus on data science and cloud computing. Pierian Training offers live instructor-led training, self-paced online video courses, and private group and cohort training programs to support enterprises looking to upskill their employees.

You May Also Like

Data Science, Tutorials

Guide to NLTK – Natural Language Toolkit for Python

Introduction Natural Language Processing (NLP) lies at the heart of countless applications we use every day, from voice assistants to spam filters and machine translation. It allows machines to understand, interpret, and generate human language, bridging the gap between humans and computers. Within the vast landscape of NLP tools and techniques, the Natural Language Toolkit […]

Machine Learning, Tutorials

GridSearchCV with Scikit-Learn and Python

Introduction In the world of machine learning, finding the optimal set of hyperparameters for a model can significantly impact its performance and accuracy. However, searching through all possible combinations manually can be an incredibly time-consuming and error-prone process. This is where GridSearchCV, a powerful tool provided by Scikit-Learn library in Python, comes to the rescue. […]

Python Basics, Tutorials

Plotting Time Series in Python: A Complete Guide

Introduction Time series data is a type of data that is collected over time at regular intervals. It can be used to analyze trends, patterns, and behaviors over time. In order to effectively analyze time series data, it is important to visualize it in a way that is easy to understand. This is where plotting […]