from django.db import models
 
# 定义一个用户模型
class User(models.Model):
    name = models.CharField(max_length=128)
    email = models.EmailField(unique=True)
 
    def __str__(self):
        return self.name
 
# 定义一个博客模型，并使用OneToOneField与User模型关联
class Blog(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    title = models.CharField(max_length=128)
 
    def __str__(self):
        return self.title
 
# 定义文章模型，使用ForeignKey与Blog模型关联
class Article(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    title = models.CharField(max_length=128)
    content = models.TextField()
 
    def __str__(self):
        return self.title
 
# 在Admin中注册模型
from django.contrib import admin
 
admin.site.register(User)
admin.site.register(Blog)
admin.site.register(Article)

这个代码示例展示了如何在Django框架中定义模型并使用不同类型的关系映射，包括OneToOneField和ForeignKey。同时，示例中包含了一个User模型，展示了如何在Django中定义一个简单的用户表，并通过Blog和Article模型来展示一对一和一对多的关系。最后，示例中还演示了如何在Django的admin后台中注册这些模型，使其可以通过管理界面进行管理。

Django是一个开放源代码的Web应用框架，采用MVC的软件设计模式，它的主要目标是使得开发者能够快速地开发一个网站，它提供了一个健壮的数据库管理工具以及一个可以被扩展的视图系统。

1. Django三板斧：

   • Model（模型）：定义了应用的数据结构及其行为。
   • View（视图）：定义了如何呈现数据和界面的逻辑。
   • Controller（控制器）：处理用户的交互和业务逻辑。

2. Django静态文件：

   Django项目中，静态文件通常存放在static文件夹内。在模板中引入静态文件，可以使用{% static %}模板标签。

   
   
   
   <link rel="stylesheet" type="text/css" href="{% static 'css/style.css' %}">
   <script type="text/javascript" src="{% static 'js/script.js' %}"></script>

3. Django的request方法：

   Django中的request对象包含了所有的HTTP请求信息。常用的方法包括：

   • request.method：获取HTTP请求方法（例如：GET, POST）。
   • request.GET：获取GET请求参数，返回QueryDict对象。
   • request.POST：获取POST请求参数，返回QueryDict对象。
   • request.FILES：获取上传的文件。

   
   
   
   from django.http import HttpResponse
    
   def my_view(request):
       if request.method == 'GET':
           # 处理GET请求
           return HttpResponse('GET方法的响应')
       elif request.method == 'POST':
           # 处理POST请求
           return HttpResponse('POST方法的响应')

以上是对Django三板斧、静态文件和request方法的简要介绍和使用示例。

from django.contrib import auth
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect
from django.http import HttpResponse
from django.template.context_processors import csrf_token
from django.views.decorators.csrf import csrf_exempt, csrf_protect
 
# 用户登录
def user_login(request):
    if request.method == 'POST':
        username = request.POST['username']
        password = request.POST['password']
        user = auth.authenticate(request, username=username, password=password)
        if user is not None:
            auth.login(request, user)
            return redirect('home')
    return render(request, 'login.html', {'csrf_token': csrf_token})
 
# 用户登出
@login_required
def user_logout(request):
    auth.logout(request)
    return redirect('home')
 
# 用户注册
def user_register(request):
    if request.method == 'POST':
        # 注册逻辑
    return render(request, 'register.html', {'csrf_token': csrf_token})
 
# 使用CSRF保护的视图
@csrf_protect
def csrf_protected_view(request):
    return HttpResponse('CSRF protected view')
 
# 禁用CSRF保护的视图
@csrf_exempt
def csrf_exempt_view(request):
    return HttpResponse('CSRF exempted view')

这个代码实例提供了用户登录、登出、注册的简单示例，并展示了如何使用Django的认证系统和会话管理功能。同时，代码中包含了如何使用装饰器login_required来保护视图，以及如何使用csrf_token上下文处理器来防止CSRF攻击。

以下是一个简化的Django图书管理系统的代码实例，展示了如何创建一个图书模型并添加基本的视图函数。

# models.py
from django.db import models
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.CharField(max_length=100)
    published_date = models.DateField()
    isbn = models.CharField(max_length=13)
 
    def __str__(self):
        return self.title
 
# views.py
from django.shortcuts import render
from django.http import HttpResponse
from .models import Book
 
def book_list(request):
    books = Book.objects.all()
    return render(request, 'books.html', {'books': books})
 
def book_create(request):
    if request.method == 'POST':
        title = request.POST.get('title')
        author = request.POST.get('author')
        published_date = request.POST.get('published_date')
        isbn = request.POST.get('isbn')
 
        new_book = Book.objects.create(
            title=title,
            author=author,
            published_date=published_date,
            isbn=isbn
        )
 
        return HttpResponse(f"Book created: {new_book}")
 
    return render(request, 'create_book.html')
 
# urls.py
from django.urls import path
from .views import book_list, book_create
 
urlpatterns = [
    path('', book_list, name='book_list'),
    path('create/', book_create, name='book_create'),
]
 
# books.html (简单的HTML表格展示图书列表)
<!DOCTYPE html>
<html>
<head>
    <title>Book List</title>
</head>
<body>
    <h1>Book List</h1>
    <ul>
        {% for book in books %}
        <li>{{ book.title }} by {{ book.author }}</li>
        {% endfor %}
    </ul>
</body>
</html>
 
# create_book.html (简单的HTML表单用于创建新图书)
<!DOCTYPE html>
<html>
<head>
    <title>Create Book</title>
</head>
<body>
    <h1>Add New Book</h1>
    <form method="post" action="">
        <label for="title">Title:</label>
        <input type="text" id="title" name="title"><br><br>
        <label for="author">Author:</label>
        <input type="text" id="author" name="author"><br><br>
        <label for="published_date">Published Date:</label>
        <input type="date" id="published_date" name="published_date"><br><br>
        <label for="isbn">ISBN

在Django中创建一个简单的项目并运行起来，你需要执行以下步骤：

1. 安装Django：

pip install django

2. 创建一个新的Django项目：

django-admin startproject myproject

3. 进入项目目录：

cd myproject

4. 运行开发服务器：

python manage.py runserver

默认情况下，开发服务器会在 localhost 的 8000 端口启动。在浏览器中打开 http://127.0.0.1:8000/，你应该能看到Django的欢迎页面。

以下是上述步骤的简要代码示例：

pip install django
django-admin startproject myproject
cd myproject
python manage.py runserver

这个简单的示例演示了如何安装Django，创建一个新项目，并启动开发服务器。

from django.shortcuts import render
from django.http import HttpResponse
from .models import Image
import os
 
def home(request):
    return render(request, 'home.html')
 
def upload(request):
    if request.method == 'POST' and request.FILES['myfile']:
        myfile = request.FILES['myfile']
        fs = FileSystemStorage()
        filename = fs.save(myfile.name, myfile)
        uploaded_file_url = fs.url(filename)
        return HttpResponse("文件上传成功。")
    return render(request, 'upload.html')
 
def list_images(request):
    images = Image.objects.all()
    return render(request, 'list_images.html', {'images': images})

在这个示例中，我们首先从django.shortcuts导入了render和HttpResponse，并从我们的应用的models.py中导入了Image模型。FileSystemStorage类用于处理文件上传。在upload函数中，我们检查是否有POST请求以及是否有上传的文件，然后将文件保存到服务器并返回文件的URL。最后，我们从数据库中获取所有图片并传递给模板，以在页面上显示。

在Django框架中，视图层是定义用户如何与网站交互的组件。视图函数是一个Python函数，它接收Web请求并返回Web响应。

以下是一个简单的Django视图函数示例，它返回一个简单的HTTP响应：

from django.http import HttpResponse
 
def welcome(request):
    return HttpResponse("欢迎访问我的网站！")

在这个例子中，welcome函数是一个视图函数。它接收一个request对象作为参数，这个对象包含了所有的HTTP请求信息，比如GET和POST参数。函数通过HttpResponse将响应发送回客户端。

在Django项目的views.py文件中定义视图函数，然后在urls.py中将URL路径与视图函数关联起来，以便Django知道当用户访问特定URL时应该执行哪个视图函数。

# urls.py
from django.urls import path
from .views import welcome
 
urlpatterns = [
    path('', welcome, name='welcome'),
]

在这个URL配置中，一个空字符串表示网站的根URL。当用户访问根URL时，Django将调用welcome视图函数来处理请求。

from django.db import connection
 
# 假设我们有一个视图函数，用于处理用户的请求，并尝试更新数据库中的记录
def update_user_profile(user_id, new_data):
    try:
        # 更新用户数据的代码
        # ...（省略其他代码）...
 
        # 假设我们在这里保存了用户对象
        user.save()
 
        # 我们还可以获取最后执行的SQL语句来查看实际发生了什么
        print("最后执行的SQL语句:", connection.queries[-1]['sql'])
    except Exception as e:
        # 如果在保存用户对象或打印SQL语句时发生异常，则捕获异常并打印出错误信息
        print(f"发生错误: {e}")
        # 此处可以添加更多的错误处理逻辑，例如记录日志、回滚事务等

这个示例代码展示了如何在Django中捕获并打印出实际执行的SQL语句，以便开发者可以分析ORM框架操作数据库时是否如预期执行。如果在执行save()方法后没有看到预期的行为，可以通过打印出的SQL语句来进一步诊断问题所在。

在Django REST framework中使用CSRF防护，首先确保django.middleware.csrf.CsrfViewMiddleware已经添加到你的MIDDLEWARE设置中。然后，对于使用@api_view或APIView的视图，你可以通过以下方式添加CSRF支持：

1. 确保你的Django项目已经包含了中间件django.middleware.csrf.CsrfViewMiddleware。
2. 对于使用TemplateResponse的视图，确保在你的模板中包含了CSRF token表单。通常，Django的模板中自动包含了这个，但是如果你使用的是不带模板的API，你可能需要手动添加。
3. 对于AJAX请求，确保在发送AJAX请求时携带CSRF cookie和header。可以通过在AJAX请求中设置X-CSRFToken头部来实现，值应该是CSRF cookie的值。

以下是一个简单的示例，展示了如何在Django REST framework中使用CSRF token：

from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt, csrf_protect
from rest_framework.views import APIView
from rest_framework.response import Response
 
@method_decorator(csrf_protect)
class MySecureView(APIView):
    def post(self, request, *args, **kwargs):
        # 这里的代码会受到CSRF保护
        return Response({'message': 'Success'})
 
# 如果你想要为特定的视图方法关闭CSRF保护，可以使用csrf_exempt装饰器
@method_decorator(csrf_exempt, name='dispatch')
class MyInsecureView(APIView):
    def post(self, request, *args, **kwargs):
        # 这里的代码不会受到CSRF保护
        return Response({'message': 'Success'})

在上面的代码中，MySecureView类使用了csrf_protect装饰器，这意味着所有通过这个类创建的视图都会强制执行CSRF保护。如果你想要关闭这个保护，可以使用csrf_exempt装饰器。

请注意，在实际部署时应当确保你的应用配置了SSL/TLS来保护数据传输的安全性，因为CSRF保护只能防止非授权的网站伪造用户的请求，而不能防止中间人攻击。

from django.shortcuts import render
from .models import Article
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
 
def article_list(request):
    object_list = Article.objects.all()
    paginator = Paginator(object_list, 10)  # 每页显示10篇文章
    page = request.GET.get('page')
    try:
        articles = paginator.page(page)
    except PageNotAnInteger:
        # 如果页数不是一个整数，展示第一页
        articles = paginator.page(1)
    except EmptyPage:
        # 如果页数超出了范围，展示最后一页
        articles = paginator.page(paginator.num_pages)
 
    return render(request, 'article_list.html', {'articles': articles})

这段代码首先从models中获取所有文章，然后创建一个Paginator对象，每页展示10篇文章。根据从GET请求中获取的page参数，它尝试获取相应的页面。如果页码不是一个整数或超出范围，它将展示相应的处理：如果页码不是整数，展示第一页；如果页码超出范围，展示最后一页。最后，它使用传递给它的文章列表渲染模板。