XQA
Back to Python
2026-03-255 min read

Contact Form (Python Programming)

Learn Contact Form (Python Programming) step by step with clear examples and exercises.

Title: Contact Form (Python Programming)

Why This Matters

A contact form is essential for websites to allow visitors to reach out and communicate with the website owner or administrator. In this lesson, we'll learn how to create a simple yet functional contact form using Python, which can handle user input and send emails with their messages. This skill will be valuable in creating interactive web applications and improving your problem-solving abilities as a programmer.

By the end of this tutorial, you'll have gained hands-on experience in:

  1. Creating an HTML form to gather user information.
  2. Reading user input from an HTML form using Python.
  3. Formatting and sending emails with the smtplib library in Python.
  4. Deploying a simple web application on a server.

Prerequisites

To follow along with this lesson, you should have a basic understanding of:

  1. Python syntax and data types (strings, lists, dictionaries)
  2. File handling using the built-in open() function
  3. Email sending with the smtplib library in Python
  4. HTML form creation and submission (optional but recommended)
  5. Basic web server setup (Apache or Nginx) for deploying the contact form
  6. Familiarity with a text editor like Sublime Text, Visual Studio Code, or Atom to write and save your code files

Core Concept

The contact form consists of an HTML form that collects user input and sends it to a Python script for processing. The Python script reads the user input, formats the email message, and sends it using the smtplib library. Let's break down each step:

  1. Create an HTML form to gather user information (name, email, subject, and message). Save this in a file named contact_form.html.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Contact Us</title>
</head>
<body>
<h1>Contact Form</h1>
<form action="/send_email" method="post">
Name: <input type="text" name="name"><br>
Email: <input type="email" name="email"><br>
Subject: <input type="text" name="subject"><br>
Message:<br>
<textarea rows="4" cols="50" name="message"></textarea><br>
<input type="submit" value="Submit">
</form>
</body>
</html>
  1. Create a Python script named send_email.py to process the form data and send an email using the smtplib library.
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText

Replace these values with your email account credentials

SMTP_SERVER = 'smtp.gmail.com'

SMTP_PORT = 587

EMAIL_ADDRESS = 'your-email@example.com'

EMAIL_PASSWORD = 'your-password'

def send_email(name, email, subject, message):

msg = MIMEMultipart()

msg['From'] = EMAIL_ADDRESS

msg['To'] = 'recipient-email@example.com'

msg['Subject'] = subject

msg.attach(MIMEText(f"Name: {name}\nEmail: {email}\n\n{message}", 'plain'))

with smtplib.SMTP(SMTP_SERVER, SMTP_PORT) as server:

server.starttls()

server.login(EMAIL_ADDRESS, EMAIL_PASSWORD)

server.sendmail(EMAIL_ADDRESS, 'recipient-email@example.com', msg.as_string())

def read_form_data():

"""Reads form data from stdin and returns a dictionary."""

form_data = {}

for line in sys.stdin:

key, value = line.strip().split('=')

form_data[key] = value

return form_data

if __name__ == "__main__":

form_data = read_form_data()

send_email(form_data['name'], form_data['email'], form_data['subject'], form_data['message'])


3. Deploy the HTML form and Python script on a web server (e.g., Apache or Nginx) to make them accessible online.

Worked Example

Assuming you have a web server set up with the contact_form.html and send_email.py files in the appropriate directories, let's test the contact form:

  1. Open your web browser and navigate to the URL where the contact form is hosted (e.g., http://example.com/contact_form.html).
  2. Fill out the form with test data (name, email, subject, and message) and click "Submit".
  3. The form data should be sent to the send_email.py script, which will process it and send an email to the recipient with the provided information.

Common Mistakes

  1. Incorrect SMTP server credentials: Make sure you use the correct SMTP server (e.g., smtp.gmail.com), port number, email address, and password for your email account.
  2. Email not being sent: Check that the recipient's email address is entered correctly in the Python script. Also, ensure that the web server has write permissions to the directory where send_email.py resides.
  3. HTML form issues: Ensure that the HTML form is well-structured and validates properly. Double-check that the form action points to the correct URL (e.g., /send_email) and that the method is set to "post".
  4. Python script not receiving data: Make sure that your web server sends the form data as POST request to the Python script. If using Flask, you can use the request object to access the form data (e.g., name = request.form['name']).
  5. Email format issues: Ensure that the email subject and message are properly formatted and don't contain any syntax errors or unescaped characters.
  6. ### Subheadings under Common Mistakes:
  • Incorrect Python script execution: Make sure your web server is configured to execute Python scripts (e.g., by setting the MIME type of send_email.py to application/x-python).
  • Server configuration issues: Ensure that your web server is properly set up and can handle POST requests from HTML forms.

Practice Questions

  1. Modify the contact form to include a captcha for spam protection.
  2. Add an error handling mechanism in the Python script to handle invalid email addresses and other common input errors.
  3. Implement a confirmation email feature that sends a message to both the user and recipient when a submission is successful.
  4. Improve the contact form design by adding styling using CSS or a popular front-end framework like Bootstrap.
  5. Integrate the contact form with a database to store and manage submitted messages more efficiently.
  6. ### Subheadings under Practice Questions:
  • Storing form data in a database: Explore SQLite, MySQL, or PostgreSQL for storing form submissions.
  • Implementing captcha protection: Research popular captcha solutions like Google reCAPTCHA and implement them in the contact form.
  • Adding email confirmation: Discuss different approaches to sending a confirmation email to both the user and recipient upon successful submission.
  • Enhancing form design: Investigate various front-end frameworks and libraries that can help you create an attractive and responsive contact form design.

FAQ

Q: Why can't I send emails from my local machine without a web server?

A: Sending emails directly from your local machine requires SMTP authentication, which isn't typically allowed for security reasons. Running the Python script on a web server allows the email to be sent through the web server's SMTP settings instead.

Q: How can I test the contact form without deploying it on a web server?

A: You can simulate a POST request using tools like curl or Postman to send the form data directly to the Python script for testing purposes.

Q: What if my email provider doesn't support SMTP authentication?

A: In that case, you may need to find an alternative email service provider that supports SMTP authentication or use a third-party API like SendGrid or Mailgun to send emails from your Python script.

Q: Can I use Flask or Django for this project instead of plain Python?

A: Yes! You can create the contact form using popular web frameworks like Flask or Django, which provide additional features and make it easier to handle user input and send emails.

Contact Form (Python Programming) | Python | XQA Learn