一文帮助快速入门Django

文章目录

• 创建django项目
• 应用app
• • 配置pycharm
  • 虚拟环境
  • 打包依赖
  • 路由
  • • 传统路由
    • include路由分发
    • name
    • namespace
    • 视图
    • 中间件
    • orm关系对象映射
    • • 操作表
      • 数据库配置
      • model常见字段及参数
      • orm基本操作
      • cookie和session
      • demo
      • • ���视图

          创建django项目

          指定版本安装django：pip install django==3.2

          命令行创建django项目：

          1. 先进入到要保存项目的目录中
          2. 然后执行：django-admin startproject 项目名

          可以看到创建了这么些文件:

          • manage.py：项目的管理工具
          • wsgi.py：提供同步的socket服务
          • asgi.py：异步
          • urls.py：主路由
          • settings.py：配置文件，只有一部分，程序启动时会先读取django内部的配置，再读取该文件的配置

            内部配置文件路径：

            编写示例代码：

            from django.urls import pathfrom django.shortcuts import HttpResponse# 调此函数会带一个request参数，可使用request获取请求数据def login(request):    # django的响应是一个封装的对象    return HttpResponse('登录成功')urlpatterns = [    # path("admin/", admin.site.urls),    path('user/login', login) # 只能写函数名]

            运行：python manage.py runserver

            指定端口运行：python manage.py runserver 127.0.0.1:8080

            执行运行命令前先进入项目目录

            应用app

            将项目分成不同的功能模块，每个模块对应一个app应用

            创建app：进入项目目录执行python manage.py startapp 应用名

            多app的创建：

            1. 在项目目录下创建apps目录，在apps目录下创建以要创的app名为名称创建目录
            2. 执行：python manage.py article apps/article
            3. 修改该文件内容
            4. 注册app

            调整示例代码结构：

            在user应用中的views.py文件编写下列代码：

            from django.shortcuts import HttpResponsedef login(request):    return HttpResponse('login success')def register(request):    return HttpResponse('register fail')

            修改urls.py文件的路由配置

            from django.urls import pathfrom user import viewsurlpatterns = [    # path('admin/', admin.site.urls),    path('login/', views.login),    path('register/', views.register)]

            启动项目，访问

            配置pycharm

            配置pycharm启动django项目：

            虚拟环境

            使用命令行创建虚拟环境：python官方用于创建虚拟环境的工具：python3.8 -m venv xxx

            该命令会基于系统python环境创建出一个虚拟环境，xxx为名称或目录

            使用第三方工具：virtualenv，先安装：pip install virtualenv

            创建：virtualenv xxx --python=python3.8

            激活：

            • win：

              cd venv/Scripts

              activate

            • mac:

              source /venv/bin/activate

              退出虚拟环境：deactivate

              打包依赖

              pip freeze > requirements.txt

              安装依赖：pip install -r requirements.txt

              路由

              传统路由

              路由系统主要是维护url与函数的映射关系

              url中包含参数：

              path('user/gethead//', views.get_head)

              类型：

              • int，整数
              • str，字符串，但不能匹配/
              • slug，字母，数字，下划线，-
              • uuid，uuid的格式
              • path，路径，可包含/

                    path('article/del//', delete),    path('article/del//', delete),    path('article/del//', delete),    path('article/del//', delete),

                直接在函数中添加参数可获取值

                def get_head(request, id):    return HttpResponse(id)

                路由中包含正则，path替换为re_path

                def article(request):    id = request.GET.get('id')    return HttpResponse(id)

                注意：参数id字段要一致

                include路由分发

                导包include

                主路由：

                from django.urls import path, include    # 路由匹配到前缀为user，则分发给apps.user中的urls，include中为路径字符串    path('user/', include('apps.user.urls')),    path('article/', include('apps.article.urls'))

                在user应用中创建urls文件，然后编写路由规则

                urlpatterns = [    path('add/', views.login)]

                效果：会先找到主路由user/，然后在分发的文件中匹配到add/，完整的路由为user/add/

                手动路由分发

                    path('user/', ([        path('del/', views.login),        path('insert/', views.insert)                   ], None, None)) # 第一个None为app_name,第二个None为namespace

                匹配的url为：user/del/，user/insert/

                include的本质

                name = 'zs'# 相当于导包 from apps.user import urlsmodule = importlib.import_module("apps.user.urls")# 也可以使用module.name获取name的值# 从module中获取name的值，如果获取不到则默认为lsn = getattr(module, 'name', 'ls')n = getattr(module, 'name') # 获取不到会直接报错

                name

                给路由起名字，可以通过名字反向生成url

                    path('user/login/', views.login, name='v1'),    path('user/register/', views.register, name='v2')

                def login(request):    # 在这个视图里，需要重定向到register里，就可以不写url，直接使用name即可    from django.urls import reverse # 需要导包    url = reverse('v2')    return redirect(url) # 重定向，里面是url地址，使用name反推出的url，不用填写真是的url地址

                namespace

                用来辅助name的，当出现同名的name时，使用name反推出url可能会出现问题，这时候就可以使用namespace来区分不同的name

                    path('user/', include('apps.user.urls', namespace='user'))

                   path('login/', views.login, name='v1'),   path('register/', views.register, name='v2')

                def login(request):    # 在这个视图里，需要重定向到register里，就可以不写url，直接使用name即可    from django.urls import reverse # 需要导包        url = reverse('user:v1') # namespace名:name名    return redirect(url) # 重定向，里面是url地址，使用name反推出的url，不用填写真是的url地址

                使用namespace时，必须提供app_name

                from django.urls import pathfrom apps.user import viewsurlpatterns = [   path('login/', views.login, name='v1'),   path('register/', views.register, name='v2')]app_name = 'user'

                如果不提供，会报错

                也可以主动去进行路由分发

                    path('user/', ([        path('login/', views.login, name='v1')    ], 'user', 'user')) # 第一个user为app_name，第二个user为namespace

                路由中尾部的/

                路由中带/，但是url不带/访问：127.0.0.1:8000/login

                path('login/', views.login)

                会发现其实是进行了两次请求，第一次找不到路经，django自动将/加上再访问一次

                这个是由于配置文件中默认APPEND_SLASH=True导致的

                如果想严格控制url，可以在settings文件中添加APPEND_SLASH=False

                再进行访问

                当前url的匹配对象

                通过request.resolver_match获取

                def login(request):    cur_obj = request.resolver_match    print(cur_obj)    return HttpResponse('login')

                拿到这个有什么用？可以做权限处理

                    path('login/', views.login, name='test')

                def login(request):    permissions = ['user', 'article', 'music'] #用户具有的权限，都是name    cur_obj = request.resolver_match.url_name #获取当前请求的name    if cur_obj not in permissions:        return HttpResponse('没有权限')    print(cur_obj)    return HttpResponse('login')

                视图

                一般功能多的时候，这样创建视图文件

                通过request对象获取请求内容

                def login(request):    print(request.path_info) # 请求url    print(request.GET.get('username')) # 获取get请求参数    print(request.GET.get('passowrd'))    print(request.headers) # 请求头   字典类型    print(request.COOKIES) # cookie  字典类型    print(request.method) # 请求方法    print(request.body) # 原始请求体    # 获取post请求参数    # 只针对body格式为a=123&b=abc，且content-type为from表单格式(application/x-www-from-urlencoded)    print(request.POST.get('username'))    print(request.POST.get('password'))    # 获取文件 请求头为multipart/form-data    request.FILES.get('name1')    request.FILES.get('name2')

                返回数据：

                1. 返回字符串/字节/文本数据

                return HttpResponse('xxx')

                1. 返回json数据

                def hello(request):    from django.http import JsonResponse    ret_dict = {        'code': 200,        'data': 'xxx'    }    return JsonResponse(ret_dict)    #return HttpResponse(json.dumps(ret_dict)) 使用json库

                1. 重定向

                return redirect('https://www.baidu.com') # 参数为url或者url的name

                设置响应头

                    ret = HttpResponse('hello world')    ret['auto'] = 'true'    ret['name'] = 'zs'    ret.set_cookie('key', 'value')    return ret

                中间件

                MiddlewareMixin

                在项目根目录下，创建middlewares目录，在该目录里创建自定义中间件

                from django.utils.deprecation import MiddlewareMixinclass MyMiddleware(MiddlewareMixin):    def process_request(self, request):        print('调用视图前')    def process_response(self, request, response):        print('调用视图后')        return response

                创建完中间件必须在settings文件中进行注册，中间件是以类定义的

                当在process_request函数中有返回值的时候，那么不会进入视图函数的执行而是接着执行process_response函数

                注意：路由匹配是在执行完process_request函数后才匹配到的，也就是process_request函数的request参数为None

                process_view

                # view_func是匹配到的路由函数，view_args，view_kwargs是路由的参数    def process_view(self, request, view_func, view_args, view_kwargs):        print(request, view_func)

                如果想在前置操作中根据视图函数做一些逻辑可以使用process_view

                process_exception

                    # 当视图中出现异常时，会捕获到    def process_exception(self, exception):        print(exception)

                orm关系对象映射

                对表的操作（表的创建，修改，删除）

                对数据的操作（增删改查）

                操作表

                在app的models.py文件创建类，一个类就对应一个表结构

                1. 按照规则创建类

                from django.db import models# 生成的表名默认为user_userinfo（app名_类名小写）class UserInfo(models.Model):# 默认会生成一个字增主键id    name = models.CharField(max_length=10)    age = models.IntegerField()        class Meta:    db_table = 'user'    verbose_name = '用户'    verbose_name_plural = verbose_name

                1. 注册app（根据注册的app找migrations目录，可以将用不到的app去掉，避免创建使用不到的表）
                2. 执行命令python manage.py makemigrations

                   会自动在app目录下的migrations目录下创建一个配置文件

                3. 执行命令python manage.py migrate，根据配置文件转换sql语句，链接数据库，执行sql

                执行上述命令前，先进行下面的数据库配置

                数据库配置

                先安装链接mysql的库pymysql/mysqlclient，pip install pymysql

                在settings文件中将默认的数据库配置修改下

                DATABASES = {    'default': {        'ENGINE': 'django.db.backends.mysql',        'NAME': 'blog', # 数据库名        'USER': 'root',        'PASSWORD': '12345678',        'HOST': '127.0.0.1',        'PORT': '3306',    }}

                使用pymysql时，在settings文件的同级目录init文件中添加如下内容

                import pymysqlpymysql.install_as_MySQLdb()

                注意：不要手动修改表结构，如果要修改可以修改models文件中的字段，再执行上述的两条命令

                数据库连接池

                pip install django-db-connection-pool

                DATABASES = {    'default': {        'ENGINE': 'django.db.backends.mysql',        'NAME': 'blog', # 数据库名        'USER': 'root',        'PASSWORD': '12345678',        'HOST': '127.0.0.1',        'PORT': '3306',        'POOL_OPTIONS': {            'POOL_SIZE': 10, # 最小连接数            'MAX_OVERFLOW': 10, # 额外增加的连接数            'RECYCLE': 24 * 60 * 60, # 每个连接最长可以使用多久            'TIMEOUT': 30,  # 无连接时，最长等待时间        }    }}

                model常见字段及参数

                class UserInfo(models.Model):    # CharField为字符串，max_length为字符串的最大长度，verbose_name字段含义，默认null=False不许为空    # 一般null和blank结合使用，null指数据库是否为可为空，blank为页面是否可为空    name = models.CharField(verbose_name='姓名', max_length=10, default='无名氏', null=True, blank=True)    # db_index表示添加索引，unique唯一约束    age = models.IntegerField(verbose_name='年龄', db_index=True, unique=True)    rage = models.BigIntegerField(verbose_name='长整型年龄')    content = models.TextField(verbose_name='详情')    # auto_now，当插入数据不传该字段时会使用当前时间    create_data = models.DateField(verbose_name='日期', auto_now=True) # 日期：年月日    rcreate_data = models.DateTimeField(verbose_name='时间') # 时间：年月日时分秒    active = models.BooleanField(verbose_name='是否')    # max_digits总共位数，decimal_places小数点后几位    salary = models.DecimalField(verbose_name='余额', max_digits=10, decimal_places=2)

                表关系

                一对多：

                class UserInfo(models.Model):    '''用户表'''    name = models.CharField(max_length=5, verbose_name='员工姓名')    age = models.IntegerField(verbose_name='年龄')    # ForeignKey外键，to表示与哪张表关联，to_field表示与哪个字段关联    # on_delete=models.CASCADE表示级联删除，models.SET_NULL表示设置为null    # models.SET_DEFAULT表示设置默认值    # 数据库生成的字段会默认给depart加上_id,depart_id    depart = models.ForeignKey(verbose_name='部门id',default=1, null=True, blank=True, to='Depart', to_field='id', on_delete=models.SET_DEFAULT)class Depart(models.Model):    '''部门表'''    name = models.CharField(verbose_name='部门名称')

                多对多：

                class UserInfo(models.Model):    name = models.CharField(max_length=5, verbose_name='姓名')class MusicInfo(models.Model):    title = models.CharField(max_length=20, verbose_name='音乐标题')class UAndM(models.Model):    nid = models.ForeignKey(to=UserInfo, to_field='id', verbose_name='用户id')    tid = models.ForeignKey(to=MusicInfo, to_field='id', verbose_name='音乐id')

                orm基本操作

                单表操作

                增：

                def register(request):    username = request.POST.get('username')    password = request.POST.get('password')    dict = {        'username': username,        'password': password    }    # 方式1    # 返回值是以UserInfo这个类创建的对象    # user = models.UserInfo.objects.create(username=username, password=password)    user = models.UserInfo.objects.create(**dict) # 匹配的参数类型是**kwargs，使用字段传参时，要带上**    print(user.username)    print(user.password)    # 批量插入    models.User.objects.bulk_create(        objs=[models.User(name='zs', age=10),models.User(name='ls', age=12)],        batch_size=2 # 一次提交几条    )    # 方式2    user1 = models.UserInfo(username='zs', password='123')    user1.save()    return HttpResponse(user)

                删：

                 # 删除    # 返回值是受影响的行数    n1 = models.UserInfo.objects.all().delete()    n2 = models.UserInfo.objects.filter(username='zs').delete()

                更新：

                # 更新    # 返回值是受影响的行数    n3 = models.UserInfo.objects.all().update(password='123')    n4 = models.UserInfo.objects.filter(username='zs').update(password='123')

                查询：

                    # 查    list = models.UserInfo.objects.all() # 返回类型是queryset（类似列表）,里面存放一个个对象    # list.query 可以获取sql语句    for obj in list:        print(obj.username)    list2 = models.UserInfo.objects.filter(username='zs') # 返回类型也是queryset    list3 = models.UserInfo.objects.filter(age__gt=10) # age>10    # age__gte=10 age>=10    # age__lt=10   age    "default": {        "BACKEND": "django.core.cache.backends.locmem.LocMemCache",    },    'redis': {        'BACKEND': 'django_redis.cache.RedisCache',        'LOCATION': 'redis://127.0.0.1:6379/1',        'OPTIONS': {            'CLIENT_CLASS': 'django_redis.client.DefaultClient',        },    },}'msg': 'login success'})    else:        return JsonResponse({'msg': 'login fail'})def home(request):    user = request.session.get('user')    if user != None:        return HttpResponse('success')    else :        return HttpResponse('fail')        let username = $("#username");        let password = $("#password");        $.ajax({            url: "/login", //请求后端路径            type: "post", //请求类型            data: {"username": username.val(), "password": password.val()}, //请求数据（json类型)            success: function(body){ //回调函数                //console.log(typeof body)                alert(body.msg)            }        });    })'id':user.id,'username':username,'password':password})