In Flask, a view function is a core component that handles user requests and returns responses. It acts as a “bridge” connecting user access to the generation of page content. From the simplest “Hello World” to dynamically displaying data, view functions offer great flexibility. Let’s explore the usage of view functions step by step.
1. First Experience with View Functions: Returning Simple Content¶
When a user accesses a specific URL, Flask automatically invokes the corresponding view function. The simplest view function can directly return a string, which Flask automatically converts into an HTML response.
from flask import Flask
app = Flask(__name__) # Create a Flask application instance
# Define the root route (triggered when accessing http://localhost:5000/)
@app.route('/')
def index():
return "Hello, Flask!" # Return a string; Flask automatically converts it to HTML
if __name__ == '__main__':
app.run(debug=True) # Start the application with debug mode enabled
After running the code, visiting the root directory will display “Hello, Flask!”, which is the result returned by the view function.
2. Returning Static HTML: Rendering Pages with Templates¶
Returning strings is suitable for simple content, but complex HTML (e.g., with titles, lists) is better managed using templates. Flask loads HTML template files via the render_template function, requiring a templates folder in the project to store these templates.
Step 1: Create a Template File¶
In the project root directory, create a templates folder and add index.html:
<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head>
<title>My First Page</title>
</head>
<body>
<h1>Welcome to the Flask World!</h1>
<p>This is a static HTML page.</p>
</body>
</html>
Step 2: Render the Template in the View Function¶
Modify the view function to load the template using render_template:
from flask import Flask, render_template # Import render_template
app = Flask(__name__)
@app.route('/')
def index():
return render_template('index.html') # Load index.html from the templates folder
if __name__ == '__main__':
app.run(debug=True)
Visiting the root directory will now display the static HTML content from the template.
3. Dynamic Data: Making Pages “Alive”¶
Templates can display dynamic content by passing data from view functions. Flask integrates with the Jinja2 template engine to support variables, loops, conditional statements, etc., enabling content to change based on data.
3.1 Template Variables: Passing Data from View Functions¶
View functions can pass dynamic content to templates using parameters. In templates, use {{ variable_name }} to render variables.
Example: Displaying Current Time
Modify the view function to get the current time and pass it to the template:
from datetime import datetime # Import the time module
@app.route('/time')
def show_time():
current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S") # Format the time
return render_template('time.html', current_time=current_time) # Pass the variable
Template File (templates/time.html):
<!DOCTYPE html>
<html>
<head>
<title>Current Time</title>
</head>
<body>
<h1>Current Time: {{ current_time }}</h1> <!-- Render the variable -->
</body>
</html>
Visiting /time will display the dynamically updated time.
3.2 Loops and Conditionals: Dynamically Displaying List Data¶
Using Jinja2 tags like {% for %} and {% if %}, you can generate lists or conditional content dynamically.
Example: Dynamic Article List
The view function provides article data, and the template uses a loop to display it:
@app.route('/articles')
def articles():
# Simulate article data (a list of dictionaries)
article_list = [
{'id': 1, 'title': 'Flask Getting Started', 'author': 'Xiaoming'},
{'id': 2, 'title': 'Python Basics', 'author': 'Xiaohong'},
{'id': 3, 'title': 'Data Analysis Practice', 'author': 'Xiaoming'}
]
return render_template('articles.html', articles=article_list) # Pass the list
Template File (templates/articles.html):
<!DOCTYPE html>
<html>
<head>
<title>Article List</title>
</head>
<body>
<h1>My Articles</h1>
<ul>
{% for article in articles %} <!-- Loop through the article list -->
<li>
<h3>{{ article.title }}</h3> <!-- Render the article title -->
<p>Author: {{ article.author }}</p>
</li>
{% endfor %}
</ul>
</body>
</html>
Visiting /articles will show a dynamically generated list of articles, with content changing based on the data.
3.3 URL Parameters: Dynamic Responses Based on User Input¶
View functions can accept dynamic parameters from the URL via route definitions, enabling personalized responses.
Example: User Profile Page
Define a route parameter <user_id> and pass it to the view function:
@app.route('/profile/<user_id>') # <user_id> is a dynamic parameter in the URL
def profile(user_id):
return f"User ID: {user_id}, This is the user's profile page"
Visiting /profile/123 will display: “User ID: 123, This is the user’s profile page”.
3.4 Request Parameters: Handling User Form Input¶
Use the request object to access data submitted by users via URL parameters or forms, enabling search, filtering, etc.
Example: Search Function
Retrieve the keyword from URL parameters and return search results:
from flask import request # Import the request module
@app.route('/search')
def search():
keyword = request.args.get('keyword', default='') # Get 'keyword' from URL parameters
return f"Search Results: Found content related to '{keyword}'..."
Visiting /search?keyword=Flask will display: “Search Results: Found content related to ‘Flask’…”.
4. Comprehensive Example: Dynamic Blog List¶
Combine the above knowledge to create a simple blog list page that supports author-based search and dynamic article display.
Project Structure¶
myblog/
├── app.py
└── templates/
└── blog.html
app.py Code¶
from flask import Flask, render_template, request
app = Flask(__name__)
# Simulate article data
articles = [
{'id': 1, 'title': 'Flask Basics', 'author': 'Xiaoming', 'date': '2023-01-01'},
{'id': 2, 'title': 'Python Scraping', 'author': 'Xiaohong', 'date': '2023-01-02'},
{'id': 3, 'title': 'Flask Advanced', 'author': 'Xiaoming', 'date': '2023-01-03'}
]
@app.route('/blog')
def blog():
# Get the author parameter from URL (default to empty string)
author = request.args.get('author', default='')
# Filter articles by author (empty string returns all articles)
filtered_articles = [a for a in articles if a['author'] == author] if author else articles
return render_template('blog.html', articles=filtered_articles, author=author)
if __name__ == '__main__':
app.run(debug=True)
Template File (templates/blog.html)¶
<!DOCTYPE html>
<html>
<head>
<title>Blog List</title>
</head>
<body>
<h1>Blog List</h1>
<!-- Search Form -->
<form method="get" action="/blog">
<input type="text" name="author" placeholder="Enter author name to search" value="{{ author }}">
<input type="submit" value="Search">
</form>
<!-- Article List -->
<ul>
{% for article in articles %}
<li>
<h3>{{ article.title }}</h3>
<p>Author: {{ article.author }} | Date: {{ article.date }}</p>
</li>
{% endfor %}
</ul>
</body>
</html>
Visiting /blog shows all articles. Entering an author name (e.g., “Xiaoming”) and clicking “Search” dynamically filters articles by that author.
Summary¶
View functions are the core of Flask, enabling you to build everything from simple static pages to complex dynamic data displays. Key capabilities include:
1. Content Return: Strings (automatically converted to HTML) or template rendering.
2. Dynamic Data: Display content using Jinja2 template variables, loops, and conditionals.
3. Parameter Handling: URL parameters and request parameters for personalized responses.
Mastering view functions allows you to quickly build interactive web applications, and they remain a foundational component when learning about databases, user authentication, and other advanced features.