# Introduction to Python Flask Framework

![Flask Logo - Flask Python Icon - Free Transparent PNG Download - PNGkey](https://th.bing.com/th/id/OIP.gc8-FBibt7bGBCR40QxYbAHaKA?rs=1&pid=ImgDetMain align="center")

---

**Flask** is a lightweight, micro web framework written in Python. It’s designed to be simple and easy to use, making it perfect for building small to medium web applications. Unlike larger frameworks like Django, Flask doesn’t come with many built-in features but gives developers the flexibility to add only what they need.

**Key Features of Flask**:

* **Lightweight**: Flask is minimalistic, allowing you to create simple web applications quickly.
    
* **Modular**: You can add only the components you need, making it flexible and customizable.
    
* **Built-in Development Server**: Flask includes a server for testing and development.
    
* **Great for Beginners**: Flask is easy to learn and a great starting point for learning web development.
    

---

**2\. Installing Flask**

Before using Flask, you need to install it. You can install Flask using the Python package manager **pip**.

In your terminal or command prompt, type:

```bash
pip install Flask
```

Once Flask is installed, you are ready to create your first Flask application.

---

**3\. Creating Your First Flask Application**

Let’s start by building a simple Flask application that displays a "Hello, World!" message when you visit a webpage.

**Basic Flask Code:**

```bash
from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return "Hello, World!"

if __name__ == '__main__':
    app.run()
```

### Code Explanation:

* `from flask import Flask`: Imports the Flask class from the Flask library.
    
* `app = Flask(__name__)`: Creates an instance of the Flask class. This object will be the web application.
    
* `@app.route('/')`: Defines a route (or URL). The `"/"` route is the homepage of the web app.
    
* `def hello_world()`: This function runs when someone visits the route `"/"`. It returns the text "Hello, World!" to the browser.
    
* `app.run()`: Starts the Flask development server.
    

### Running the Application:

1. Save the file as `app.py`.
    
2. Run the file using the command:
    
    ```bash
    python app.py
    ```
    
3. In your browser, go to `http://127.0.0.1:5000/`. You should see "Hello, World!" displayed.
    

---

**4\. Flask Routing**

Flask uses **routing** to map URLs to Python functions. You can define multiple routes, each associated with a different function.

**Example of Multiple Routes**:

```bash
from flask import Flask

app = Flask(__name__)

@app.route('/')
def home():
    return "Welcome to the Home Page!"

@app.route('/about')
def about():
    return "This is the About Page."

if __name__ == '__main__':
    app.run()
```

### Code Explanation:

* `@app.route('/')`: The homepage route.
    
* `@app.route('/about')`: The `/about` route will show a message when you visit `http://127.0.0.1:5000/about`.
    

You can create routes for different parts of the website, like `/contact`, `/profile`, etc.

---

**5\. Dynamic URL Routing**

Flask allows you to create dynamic routes, where part of the URL can change. This is useful for things like user profiles or blog posts, where you might want to show different data based on the URL.

**Example of Dynamic Routes**:

```bash
from flask import Flask

app = Flask(__name__)

@app.route('/user/<name>')
def user(name):
    return f"Hello, {name}!"

if __name__ == '__main__':
    app.run()
```

### Code Explanation:

* `@app.route('/user/<name>')`: The `<name>` in the route is a placeholder for a dynamic value.
    
* `return f"Hello, {name}!"`: The `f"{}"` syntax is used to insert the value of `name` into the string.
    

When you visit `http://127.0.0.1:5000/user/Alice`, it will display "Hello, Alice!". You can replace "Alice" with any name in the URL.

---

**6\. Handling HTTP Methods**

Flask supports different HTTP methods, such as **GET** and **POST**. By default, routes use the `GET` method, which is used to retrieve data from the server. The `POST` method is often used to send data to the server, such as form submissions.

**GET and POST Example**:

```bash
from flask import Flask, request

app = Flask(__name__)

@app.route('/greet', methods=['GET', 'POST'])
def greet():
    if request.method == 'POST':
        name = request.form['name']
        return f"Hello, {name}!"
    return '''
        <form method="post">
            Name: <input type="text" name="name">
            <input type="submit" value="Submit">
        </form>
    '''

if __name__ == '__main__':
    app.run()
```

### Code Explanation:

* `methods=['GET', 'POST']`: Specifies that the `/greet` route can handle both GET and POST requests.
    
* `request.method`: Checks if the request is a `POST` or `GET`.
    
* `request.form['name']`: Retrieves the value of the `name` field from the form.
    

### How It Works:

1. When you visit `/greet` in your browser, you will see a form asking for your name.
    
2. After entering your name and submitting the form, the server will respond with a personalized greeting using the POST method.
    

---

**7\. Templates in Flask**

In most web applications, you will want to separate the HTML code from your Python code. Flask allows you to use **templates** to do this. Templates are HTML files that can be dynamically generated with data from your Flask app.

**Using Templates Example**:

1. Create a folder called `templates` in your project directory.
    
2. Inside the `templates` folder, create a file called `hello.html` with the following content:
    
    ```bash
    <!DOCTYPE html>
    <html>
    <body>
        <h1>Hello, {{ name }}!</h1>
    </body>
    </html>
    ```
    
3. Modify your Flask app to use this template:
    
    ```bash
    from flask import Flask, render_template
    
    app = Flask(__name__)
    
    @app.route('/user/<name>')
    def user(name):
        return render_template('hello.html', name=name)
    
    if __name__ == '__main__':
        app.run()
    ```
    

### Code Explanation:

* `render_template('hello.html', name=name)`: Renders the `hello.html` template and passes the `name` variable to the template.
    
* `{{ name }}`: This is Jinja2 template syntax, which allows you to insert dynamic content into your HTML file.
    

Now, when you visit `http://127.0.0.1:5000/user/Alice`, the browser will display an HTML page with "Hello, Alice!".

---

**8\. Flask Forms and User Input**

Flask allows handling forms easily using **Flask-WTF**, a form-handling extension. For now, let's keep it simple by handling forms without external libraries.

In the previous example, we already demonstrated a basic form. Let’s expand on that by processing form input to create a personalized user experience.

**Example of Handling Forms**:

```bash
from flask import Flask, request, render_template

app = Flask(__name__)

@app.route('/submit', methods=['GET', 'POST'])
def submit():
    if request.method == 'POST':
        name = request.form['name']
        return render_template('hello.html', name=name)
    return '''
        <form method="post">
            Name: <input type="text" name="name">
            <input type="submit" value="Submit">
        </form>
    '''

if __name__ == '__main__':
    app.run()
```

Here, the user submits a name through a form, and the server processes it to render the template with a personalized greeting.

---

Flask is a simple and flexible framework that allows you to build anything from simple web pages to complex applications. Its modular nature allows you to start with small, simple projects and expand as you learn more.

**References**:

1. Grinberg, Miguel. “Flask Web Development.” *Flask Documentation*, https://flask.palletsprojects.com/
    
2. "Flask: A Simple Framework for Building Complex Web Applications." *RealPython*, https://realpython.com/flask-by-example/