Are you looking to showcase your awesome coding skills, projects, and experiences to potential employers or collaborators? A personal portfolio website is an incredible tool for doing just that! It’s your digital resume, a dynamic space where you can demonstrate what you’ve built and what you’re capable of.
In this guide, we’re going to walk through how to build a simple, yet effective, portfolio website using Flask and Python. Don’t worry if you’re a beginner; we’ll break down every step with easy-to-understand explanations.
Why a Portfolio? Why Flask?
First things first, why is a portfolio so important?
* Show, Don’t Just Tell: Instead of just listing your skills, a portfolio allows you to show your projects in action.
* Stand Out: It helps you differentiate yourself from other candidates by providing a unique insight into your work ethic and creativity.
* Practice Your Skills: Building your own portfolio is a fantastic way to practice and solidify your web development skills.
Now, why Flask?
Flask is a “micro” web framework written in Python.
* Web Framework: Think of a web framework as a set of tools and guidelines that make building websites much easier. Instead of building everything from scratch, frameworks give you a head start with common functionalities.
* Microframework: “Micro” here means Flask aims to keep the core simple but extensible. It doesn’t force you to use specific tools or libraries for everything, giving you a lot of flexibility. This makes it perfect for beginners because you can learn the essentials without being overwhelmed.
* Python: If you already know Python, Flask lets you leverage that knowledge to build powerful web applications without needing to learn a completely new language for the backend.
Getting Started: Setting Up Your Environment
Before we write any code, we need to set up our development environment. This ensures our project has everything it needs to run smoothly.
1. Install Python
If you don’t have Python installed, head over to the official Python website (python.org) and download the latest version suitable for your operating system. Make sure to check the box that says “Add Python X.X to PATH” during installation if you’re on Windows – this makes it easier to run Python commands from your terminal.
2. Create a Project Folder
It’s good practice to keep your projects organized. Create a new folder for your portfolio. You can name it something like my_portfolio.
mkdir my_portfolio
cd my_portfolio
3. Set Up a Virtual Environment
A virtual environment is like an isolated sandbox for your Python projects. It allows you to install specific versions of libraries (like Flask) for one project without affecting other projects or your main Python installation. This prevents conflicts and keeps your projects clean.
Inside your my_portfolio folder, run the following command:
python -m venv venv
python -m venv: This tells Python to run thevenvmodule.venv: This is the name we’re giving to our virtual environment folder. You can name it anything, butvenvis a common convention.
Now, activate your virtual environment:
- On macOS/Linux:
bash
source venv/bin/activate - On Windows (Command Prompt):
bash
venv\Scripts\activate - On Windows (PowerShell):
powershell
.\venv\Scripts\Activate.ps1
You’ll know it’s activated because you’ll see (venv) at the beginning of your terminal prompt.
4. Install Flask
With your virtual environment activated, install Flask using pip.
pip is Python’s package installer, used to install and manage libraries.
pip install Flask
Your First Flask Application: “Hello, Portfolio!”
Now that everything is set up, let’s create a very basic Flask application.
Inside your my_portfolio folder, create a new file named app.py.
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
"""
This function handles requests to the root URL ('/').
It returns a simple message.
"""
return "<h1>Welcome to My Awesome Portfolio!</h1>"
if __name__ == '__main__':
app.run(debug=True)
Let’s break down this code:
* from flask import Flask: This line imports the Flask class from the flask library.
* app = Flask(__name__): This creates an instance of the Flask application. __name__ is a special Python variable that represents the name of the current module. Flask uses it to figure out where to look for static files and templates.
* @app.route('/'): This is a decorator. It tells Flask that the home() function should be executed whenever a user navigates to the root URL (/) of your website. This is called a route.
* def home():: This defines a Python function that will be called when the / route is accessed.
* return "<h1>Welcome to My Awesome Portfolio!</h1>": This function returns a string of HTML. Flask sends this string back to the user’s browser, which then displays it.
* if __name__ == '__main__':: This standard Python construct ensures that app.run() is only called when you run app.py directly (not when it’s imported as a module into another script).
* app.run(debug=True): This starts the Flask development server.
* debug=True: This enables debug mode. In debug mode, your server will automatically reload when you make changes to your code, and it will also provide helpful error messages in your browser if something goes wrong. (Remember to turn this off for a production server!)
To run your application, save app.py and go back to your terminal (with your virtual environment activated). Run:
python app.py
You should see output similar to this:
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on http://127.0.0.1:5000
Press CTRL+C to quit
* Restarting with stat
* Debugger is active!
* Debugger PIN: ...
Open your web browser and navigate to http://127.0.0.1:5000 (or http://localhost:5000). You should see “Welcome to My Awesome Portfolio!” displayed. Congratulations, your first Flask app is running!
Structuring Your Portfolio: Templates and Static Files
Returning HTML directly from your Python code (like return "<h1>...") isn’t practical for complex websites. We need a way to keep our HTML, CSS, and images separate. This is where Flask’s templates and static folders come in.
- Templates: These are files (usually
.html) that contain the structure and content of your web pages. Flask uses a templating engine called Jinja2 to render them. - Static Files: These are files that don’t change often, like CSS stylesheets, JavaScript files, and images.
Let’s organize our project:
1. Inside your my_portfolio folder, create two new folders: templates and static.
2. Inside static, create another folder called css.
Your project structure should look like this:
my_portfolio/
├── venv/
├── app.py
├── static/
│ └── css/
│ └── style.css (we'll create this next)
└── templates/
└── index.html (we'll create this next)
1. Create a CSS File (static/css/style.css)
/* static/css/style.css */
body {
font-family: Arial, sans-serif;
margin: 40px;
background-color: #f4f4f4;
color: #333;
line-height: 1.6;
}
h1 {
color: #0056b3;
}
p {
margin-bottom: 10px;
}
.container {
max-width: 800px;
margin: auto;
background: #fff;
padding: 30px;
border-radius: 8px;
box-shadow: 0 2px 5px rgba(0,0,0,0.1);
}
nav ul {
list-style: none;
padding: 0;
background: #333;
overflow: hidden;
border-radius: 5px;
}
nav ul li {
float: left;
}
nav ul li a {
display: block;
color: white;
text-align: center;
padding: 14px 16px;
text-decoration: none;
}
nav ul li a:hover {
background-color: #555;
}
2. Create an HTML Template (templates/index.html)
<!-- templates/index.html -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>My Portfolio</title>
<!-- Link to our CSS file -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
<div class="container">
<nav>
<ul>
<li><a href="/">Home</a></li>
<li><a href="/about">About</a></li>
<li><a href="/projects">Projects</a></li>
<li><a href="/contact">Contact</a></li>
</ul>
</nav>
<h1>Hello, I'm [Your Name]!</h1>
<p>Welcome to my personal portfolio. Here you'll find information about me and my exciting projects.</p>
<h2>About Me</h2>
<p>I am a passionate [Your Profession/Interest] with a strong interest in [Your Specific Skills/Areas]. I enjoy [Your Hobby/Learning Style].</p>
<h2>My Projects</h2>
<p>Here are a few highlights of what I've been working on:</p>
<ul>
<li><strong>Project Alpha:</strong> A web application built with Flask for managing tasks.</li>
<li><strong>Project Beta:</strong> A data analysis script using Python and Pandas.</li>
<li><strong>Project Gamma:</strong> A small game developed using Pygame.</li>
</ul>
<h2>Contact Me</h2>
<p>Feel free to reach out to me via email at <a href="mailto:your.email@example.com">your.email@example.com</a> or connect with me on <a href="https://linkedin.com/in/yourprofile">LinkedIn</a>.</p>
</div>
</body>
</html>
Notice this line in the HTML: <link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">.
* {{ ... }}: This is Jinja2 templating syntax.
* url_for(): This is a special Flask function that generates a URL for a given function. Here, url_for('static', filename='css/style.css') tells Flask to find the static folder and then locate the css/style.css file within it. This is more robust than hardcoding paths.
3. Update app.py to Render the Template
Now, modify your app.py file to use the index.html template. We’ll also add placeholder routes for other pages.
from flask import Flask, render_template
app = Flask(__name__)
@app.route('/')
def home():
"""
Renders the index.html template for the home page.
"""
return render_template('index.html')
@app.route('/about')
def about():
return render_template('about.html') # We will create this template later
@app.route('/projects')
def projects():
return render_template('projects.html') # We will create this template later
@app.route('/contact')
def contact():
return render_template('contact.html') # We will create this template later
if __name__ == '__main__':
app.run(debug=True)
from flask import Flask, render_template: We’ve addedrender_templateto our import.render_template('index.html'): This function tells Flask to look inside thetemplatesfolder for a file namedindex.html, process it using Jinja2, and then send the resulting HTML to the user’s browser.
Save app.py. If your Flask server was running in debug mode, it should have automatically reloaded. Refresh your browser at http://127.0.0.1:5000. You should now see your portfolio page with the applied styling!
To make the /about, /projects, and /contact links work, you would create about.html, projects.html, and contact.html files inside your templates folder, similar to how you created index.html. For a simple portfolio, you could even reuse the same basic structure and just change the main content.
What’s Next? Expanding Your Portfolio
You’ve built the foundation! Here are some ideas for how you can expand and improve your portfolio:
- More Pages: Create dedicated pages for each project with detailed descriptions, screenshots, and links to live demos or GitHub repositories.
- Dynamic Content: Learn how to pass data from your Flask application to your templates. For example, you could have a Python list of projects and dynamically display them on your projects page using Jinja2 loops.
- Contact Form: Implement a simple contact form. This would involve handling form submissions in Flask (using
request.form) and potentially sending emails. - Database: For more complex portfolios (e.g., if you want to add a blog or manage projects easily), you could integrate a database like SQLite or PostgreSQL using an Object-Relational Mapper (ORM) like SQLAlchemy.
- Deployment: Once your portfolio is ready, learn how to deploy it to a live server so others can see it! Popular options include Heroku, PythonAnywhere, Vercel, or DigitalOcean.
Conclusion
Building a portfolio with Flask and Python is an excellent way to not only showcase your work but also to deepen your understanding of web development. You’ve learned how to set up your environment, create a basic Flask application, organize your project with templates and static files, and render dynamic content. Keep experimenting, keep building, and soon you’ll have a stunning online presence that truly reflects your skills!