首頁手記 Python Web開發入門指南

Python Web開發入門指南

標簽：

Java

Python 是一种广泛使用的高级编程语言，以其简洁而强大的语法和丰富的库支持，使得它成为许多开发者的选择。Python 在 Web 开发领域也有着广泛的使用。本指南将带你了解如何使用 Python 进行 Web 开发。我们将从基础概念开始，逐步介绍 Flask 和 Django 两个框架，并通过具体的例子来演示如何使用它们。

Python Web开发的基础知识

Python 有很多 Web 开发框架，这里我们主要介绍两个常用的框架：Flask 和 Django。这些框架能够帮助开发者快速构建 Web 应用程序，提供了许多便捷的功能，包括路由、模板、数据库支持等。

Flask: Flask 是一个轻量级的 Python Web 开发框架，具有高度的可扩展性和灵活性。它非常适合小型项目以及需要高度定制化的应用。
Django: Django 是一个高级的 Python Web 开发框架，采用“不重复造轮子”的原则，内置了许多强大的特性，如 ORM（对象关系映射）、模板系统、用户认证等。它适合开发大型、复杂的应用程序。

选择哪个框架取决于具体的应用需求和团队的技术背景。例如，如果项目规模较小，希望开发速度快，可以选择 Flask。如果项目规模较大，需要丰富功能和成熟的工具支持，则 Django 会是更好的选择。

Flask框架入门

Flask 是一个使用简单但功能强大的 Web 框架。它允许我们快速构建应用，并且可以根据需要进行扩展。Flask 的核心特性包括：

灵活的路由系统：可以定义 URL 路由，轻松处理 GET 和 POST 请求。
简易的模板引擎：支持 Jinja2 模板引擎，用于动态生成 HTML 页面。
扩展插件：支持各种第三方扩展，如数据库支持、缓存、认证等。

安装 Flask

使用 pip 安装 Flask 框架：

pip install Flask

创建第一个 Flask 应用

创建一个简单的 Flask 应用来学习基本用法。首先，创建一个名为 app.py 的文件，然后编写如下代码：

from flask import Flask, render_template

app = Flask(__name__)

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

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

@app.route('/about')
def about():
    return render_template('about.html')

if __name__ == '__main__':
    app.run(debug=True)

上述代码中：

Flask 类被用来创建一个 Flask 应用实例。
@app.route() 装饰器用于定义路由，即 URL 路径。
render_template() 函数用于渲染 Jinja2 模板，生成 HTML 页面。

在项目的根目录下创建一个名为 templates 的文件夹，并在其中创建 about.html 文件：

<!DOCTYPE html>
<html>
<head>
    <title>About Us</title>
</head>
<body>
    <h1>About Us</h1>
    <p>This is an about page for our application.</p>
</body>
</html>

运行 app.py 文件，访问 http://127.0.0.1:5000 和 http://127.0.0.1:5000/about 来查看应用效果。

Django框架入门

Django 是一个成熟的、功能丰富的 Web 框架，适合开发大型、复杂的应用。它内置了许多实用的工具，如 ORM、用户认证系统、管理界面等。

安装 Django

使用 pip 安装 Django：

pip install Django

创建第一个 Django 项目

使用命令行工具创建一个新项目：

django-admin startproject myproject

进入项目目录，创建新的应用：

cd myproject
django-admin startapp myapp

编写简单的 Django 视图

在 myapp/views.py 文件中定义视图函数：

from django.http import HttpResponse
from django.shortcuts import render

def index(request):
    return HttpResponse("Hello, Django!")

def about(request):
    return render(request, 'about.html')

在 myapp 目录下创建一个新的 templates 文件夹，并在其中创建 about.html 文件：

<!DOCTYPE html>
<html>
<head>
    <title>About Us</title>
</head>
<body>
    <h1>About Us</h1>
    <p>This is an about page for our application.</p>
</body>
</html>

接下来，需要将视图与 URL 路由关联起来。在 myapp 目录下创建 urls.py 文件，并编写如下代码：

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('about/', views.about, name='about'),
]

还要将应用和 URL 路由注册到项目中。修改 myproject/urls.py 文件，将 myapp 的 URL 路由包含进来：

from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('myapp.urls')),
]

最后，在 myproject/settings.py 文件中，确保 INSTALLED_APPS 列表中包含 'myapp'。

运行 Django 开发服务器

在命令行中运行以下命令启动开发服务器：

python manage.py runserver

访问 http://127.0.0.1:8000 和 http://127.0.0.1:8000/about 查看应用效果。

数据库与 ORM

无论是 Flask 还是 Django，都支持通过 ORM（对象关系映射）来操作数据库。ORM 抽象了 SQL 的细节，使得开发者可以更专注于业务逻辑。

SQLite 数据库

SQLite 是一个轻量级的数据库，适用于小型项目和开发阶段。它不需要单独的服务器进程，所有的数据库操作都是通过一个独立的库来完成的。

Flask 中的 SQLite 数据库

安装 SQLite 相关库：

pip install flask_sqlalchemy

在 app.py 文件中引入并配置 SQLite 数据库：

from flask import Flask, render_template
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(20), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

    def __repr__(self):
        return f"User('{self.username}', '{self.email}')"

@app.route('/')
def index():
    return "Database example with Flask"

if __name__ == '__main__':
    app.run(debug=True)

运行 app.py 文件，数据库将被初始化并创建 User 表。

Django 中的 SQLite 数据库

Django 默认使用 SQLite 作为数据库。在 settings.py 文件中配置数据库连接：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': 'db.sqlite3',
    }
}

创建一个新的模型 models.py 文件：

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=20, unique=True)
    email = models.EmailField(unique=True)

    def __str__(self):
        return f"User('{self.username}', '{self.email}')"

运行以下命令创建数据库表：

python manage.py makemigrations
python manage.py migrate

使用 Flask 和 Django 进行用户认证

在 Web 开发中，用户认证是一个常见的需求。Flask 和 Django 都提供了内置的用户认证功能，使得开发更加便捷。

Flask 用户认证

Flask-Login 是一个用于管理用户会话的扩展。

安装 Flask-Login：

pip install flask-login

在 app.py 文件中引入并配置用户认证：

from flask import Flask, render_template, redirect, url_for, flash
from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user

app = Flask(__name__)
app.config['SECRET_KEY'] = 'mysecretkey'
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

class User(UserMixin):
    def __init__(self, id, username, email):
        self.id = id
        self.username = username
        self.email = email

@login_manager.user_loader
def load_user(user_id):
    return User(user_id, 'user', '[email protected]')

@app.route('/')
@login_required
def index():
    return 'Hello, {}!'.format(current_user.username)

@app.route('/login')
def login():
    user = load_user(1)
    login_user(user)
    return redirect(url_for('index'))

@app.route('/logout')
@login_required
def logout():
    logout_user()
    return redirect(url_for('login'))

if __name__ == '__main__':
    app.run(debug=True)

Django 用户认证

Django 内置了用户认证系统，使用 auth 应用。

在 myapp/views.py 文件中定义登录和注销视图：

from django.shortcuts import render, redirect
from django.contrib.auth import login, logout, authenticate

def login_view(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            return redirect('index')
        else:
            return render(request, 'login.html', {'error': 'Invalid credentials'})
    return render(request, 'login.html')

def logout_view(request):
    logout(request)
    return redirect('login')

创建对应的模板文件 login.html：

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    {% if error %}
        <p>{{ error }}</p>
    {% endif %}
    <form method="post">
        {% csrf_token %}
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required>
        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required>
        <input type="submit" value="Login">
    </form>
</body>
</html>

在 myapp/urls.py 文件中添加视图路由：

from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),
    path('about/', views.about, name='about'),
    path('login/', views.login_view, name='login'),
    path('logout/', views.logout_view, name='logout'),
]

使用 Flask 和 Django 进行表单处理

在 Web 开发中，处理表单数据是一项常见任务。Flask 和 Django 都提供了便捷的方式来处理表单。

Flask 表单处理

Flask-WTF 是一个用于处理表单的扩展，使用 WTForms 库。

安装 Flask-WTF：

pip install flask-wtf

在 app.py 文件中定义表单类并处理表单提交：

from flask import Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired

app = Flask(__name__)
app.config['SECRET_KEY'] = 'mysecretkey'

class LoginForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])
    submit = SubmitField('Login')

@app.route('/')
def index():
    return "Home Page"

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        return f"Username: {form.username.data}, Password: {form.password.data}"
    return render_template('login.html', form=form)

if __name__ == '__main__':
    app.run(debug=True)

创建模板文件 login.html：

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <form method="post">
        {{ form.hidden_tag() }}
        <p>
            {{ form.username.label }}<br>
            {{ form.username(size=20) }}
        </p>
        <p>
            {{ form.password.label }}<br>
            {{ form.password(size=20) }}
        </p>
        <p>{{ form.submit() }}</p>
    </form>
</body>
</html>

Django 表单处理

Django 内置了表单处理功能，使用 forms 应用。

在 myapp/forms.py 文件中定义表单类：

from django import forms

class LoginForm(forms.Form):
    username = forms.CharField(max_length=20, label='Username')
    password = forms.CharField(max_length=20, widget=forms.PasswordInput, label='Password')

在 myapp/views.py 文件中处理表单提交：

from django.shortcuts import render
from django.http import HttpResponse
from .forms import LoginForm
from django.contrib.auth import authenticate, login as auth_login

def login_view(request):
    form = LoginForm()
    if request.method == 'POST':
        form = LoginForm(request.POST)
        if form.is_valid():
            username = form.cleaned_data['username']
            password = form.cleaned_data['password']
            user = authenticate(request, username=username, password=password)
            if user is not None:
                auth_login(request, user)
                return redirect('index')
            else:
                return render(request, 'login.html', {'form': form, 'error': 'Invalid credentials'})
    return render(request, 'login.html', {'form': form})

创建模板文件 login.html：

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    {% if error %}
        <p>{{ error }}</p>
    {% endif %}
    <form method="post">
        {% csrf_token %}
        {{ form.as_p }}
        <p><input type="submit" value="Login"></p>
    </form>
</body>
</html>

缓存与性能优化

在 Web 应用中，性能优化是一个重要的方面。使用缓存可以显著提升应用的响应速度和用户体验。

Flask 缓存

Flask-Caching 是一个用于缓存的扩展。

安装 Flask-Caching：

pip install flask-caching

在 app.py 文件中引入并配置缓存：

from flask import Flask, render_template
from flask_caching import Cache

app = Flask(__name__)
cache = Cache(app, config={'CACHE_TYPE': 'simple'})

@app.route('/')
@cache.cached(timeout=50)
def index():
    return "Cached response"

if __name__ == '__main__':
    app.run(debug=True)

Django 缓存

Django 内置了缓存功能，可以在 settings.py 文件中进行配置。

在 settings.py 文件中设置缓存后端：

CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
    }
}

在视图中使用缓存：

from django.core.cache import cache
from django.http import HttpResponse

def index(request):
    if 'counter' not in cache:
        cache['counter'] = 0
    cache['counter'] += 1
    return HttpResponse(f"Counter: {cache['counter']}")

增加一个实例

在 Flask 中，使用缓存来优化一个简单的函数：

@app.route('/counter')
@cache.cached(timeout=300)
def counter():
    return "This is a cached response"

在 Django 中，使用缓存来优化一个视图：

from django.views.decorators.cache import cache_page

@cache_page(60)
def cached_view(request):
    return render(request, 'cached_view.html')

错误处理与调试

Web 应用经常会出现各种错误，有效的错误处理和调试机制可以提高开发效率和用户体验。

Flask 错误处理

在 app.py 文件中定义自定义错误处理函数：

from flask import Flask, render_template

app = Flask(__name__)

@app.errorhandler(404)
def page_not_found(e):
    return render_template('404.html'), 404

@app.route('/')
def index():
    if request.method == 'POST':
        # Perform some action
        pass
    else:
        abort(404)
    return "Hello, World!"

if __name__ == '__main__':
    app.run(debug=True)

创建模板文件 404.html：

<!DOCTYPE html>
<html>
<head>
    <title>404 Not Found</title>
</head>
<body>
    <h1>404 Not Found</h1>
    <p>The requested URL was not found on the server.</p>
</body>
</html>

Django 错误处理

在 settings.py 文件中设置全局错误处理视图：

from django.conf import settings
from django.http import HttpResponseServerError

def handler500(request):
    return HttpResponseServerError('<h1>Custom error 500 page</h1>')

在 urls.py 文件中添加自定义错误处理视图：

from django.urls import path
from . import views

handler404 = views.handler404
handler500 = views.handler500

日志记录

记录日志有助于追踪应用运行情况和排查问题。

Flask 日志记录

在 app.py 文件中引入日志库，并设置日志级别：

import logging
from flask import Flask

app = Flask(__name__)
logging.basicConfig(filename='app.log', level=logging.DEBUG)

@app.route('/')
def index():
    logging.debug('Debug message')
    logging.info('Info message')
    logging.warning('Warning message')
    logging.error('Error message')
    logging.critical('Critical message')
    return "Hello, World!"

if __name__ == '__main__':
    app.run(debug=True)

Django 日志记录

在 settings.py 文件中配置日志记录：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'django.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

增加一个实例

在 Flask 中，详细记录一个复杂的操作日志：

@app.route('/log_test')
def log_test():
    logging.info("Starting log_test")
    try:
        # Do some critical operations
        raise Exception('Test exception')
    except Exception as e:
        logging.error(f"Exception occurred: {e}")
    logging.info("Finished log_test")
    return "Log test complete"

在 Django 中，记录一个视图操作的日志：

from django.http import HttpResponse
import logging

logger = logging.getLogger(__name__)

def log_view(request):
    logger.info("Processing log_view")
    # Perform some operations
    logger.info("Finished processing log_view")
    return HttpResponse("Log view processed")

部署与发布

将 Web 应用部署到生产环境是发布应用的重要步骤。这里我们将介绍如何使用 Gunicorn 和 uWSGI 服务器来运行 Flask 和 Django 应用，并使用 Nginx 作为反向代理。

使用 Gunicorn 运行 Flask 应用

安装 Gunicorn：

pip install gunicorn

在命令行中运行 Gunicorn 服务器：

gunicorn app:app

使用 uWSGI 运行 Flask 应用

安装 uWSGI：

pip install uwsgi

创建一个 uwsgi.ini 配置文件：

[uwsgi]
module = app
master = true
processes = 4
socket = 127.0.0.1:8000
vacuum = true
chmod-socket = 666
die-on-segfault = true

运行 uWSGI 服务器：

uwsgi --ini uwsgi.ini

使用 Gunicorn 运行 Django 应用

在命令行中运行 Gunicorn 服务器：

gunicorn myproject.wsgi:application --bind 127.0.0.1:8000

使用 uWSGI 运行 Django 应用

创建一个 uwsgi.ini 配置文件：

[uwsgi]
chdir = /path/to/myproject
module = myproject.wsgi:application
master = true
processes = 4
socket = 127.0.0.1:8000
vacuum = true
chmod-socket = 666
die-on-segfault = true

运行 uWSGI 服务器：

uwsgi --ini uwsgi.ini

使用 Nginx 作为反向代理

安装 Nginx：

sudo apt-get install nginx

配置 Nginx 反向代理：

编辑 /etc/nginx/sites-available/default 文件：

server {
    listen 80;
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

重启 Nginx 服务：

sudo systemctl restart nginx

结语

通过本文的学习，你已经了解了如何使用 Python 进行 Web 开发，包括使用 Flask 和 Django 两个框架的基本步骤。从基础概念到高级功能，我们一步一步介绍了如何构建和部署 Web 应用。希望这些内容能帮助你更深入地理解 Python Web 开发，并在实际项目中应用这些知识。

點擊查看更多內容

為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

評論

共同學習，寫下你的評論

評論加載中...

展開查看更多評論

作者其他優質文章

正在加載中

侃侃爾雅

手記
篇

粉絲

10

獲贊與收藏

13

關注作者，訂閱最新文章

閱讀免費教程

Java并發工具

23個小節 19844 321

Java 并發原理入門教程

26個小節 40021 580

Java 入門教程

50個小節 351802 3256

推薦

評論

收藏

共同學習，寫下你的評論



感謝您的支持，我會繼續努力的～

掃碼打賞，你說多少就多少

贊賞金額會直接到老師賬戶

支付方式

打開微信掃一掃，即可進行掃碼打賞哦

今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與放棄機會

點擊
抽獎

慕課手記新用戶專享福利

恭喜你，你的運氣太好了，居然抽中了 100個積分！

恭喜你，抽中了價值元的專欄！

太棒了，直接落到你賬戶里！

積分商城里的羅技鼠標、機械鍵盤、
Kindle 閱讀器、小米平衡車
Apple iPad （10.2英寸）、大額優惠券
在等著你去兌換了噢

作者：

免費贈送

兌換碼：1111222211 復制

優惠券可用于購買實戰課、體系課
無門檻使用

先去看看，有什么好東西馬上兌換我愛學習，選課去


亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

熱搜

最近搜索清空

Python Web開發入門指南

安装 Flask

创建第一个 Flask 应用

安装 Django

创建第一个 Django 项目

编写简单的 Django 视图

运行 Django 开发服务器

SQLite 数据库

Flask 中的 SQLite 数据库

Django 中的 SQLite 数据库

使用 Flask 和 Django 进行用户认证

Flask 用户认证

Django 用户认证

使用 Flask 和 Django 进行表单处理

Flask 表单处理

Django 表单处理

Flask 缓存

Django 缓存

增加一个实例

Flask 错误处理

Django 错误处理

日志记录

Flask 日志记录

Django 日志记录

增加一个实例

使用 Gunicorn 运行 Flask 应用

使用 uWSGI 运行 Flask 应用

使用 Gunicorn 运行 Django 应用

使用 uWSGI 运行 Django 应用

使用 Nginx 作为反向代理

閱讀免費教程