Django基础--2

一、路由系统 URL

1.模板语言循环字典

1.简单的字典循环

<ul>

        {% for i in user_dict %}

        <li>{{ i }}</li>

        {% endfor %}

    </ul>

获取字典中的key

<ul>

        {% for i in user_dict.keys %}

        <li>{{ i }}</li>

        {% endfor %}

    </ul>

获取字典中的key,通过keys关键字，不要括号

<ul>

        {% for i in user_dict.values %}

        <li>{{ i }}</li>

        {% endfor %}

    </ul>

获取字典中的value,通过values关键字，不要括号

<ul>

        {% for i in user_dict.items %}

        <li>{{ i }}</li>

        {% endfor %}

    </ul>

获取字典中的key和value,得到的是个元组

<ul>

        {% for i,j in user_dict.items %}

        <li>{{ i }}---{{ j }}</li>

        {% endfor %}

    </ul>

分别获取字典中的key，value,

{% for i in user_dict %}      {% for i in user_dict.keys %}     {% for i in user_dict.values %}          {% for i in user_dict.items %}         {% for i,j in user_dict.items %}

循环字典，和python里是差不多的，就是后面没有括号()：

直接dict ：循环的是key
dict.keys ：循环key
dict.values ：循环values
dict.items ：循环key和values

2.一条对应关系对应多个页面

这里通过嵌套字典来实现

场景：一个页面会显示很多用户的某个信息，然后我们点击查看详情，会出来用户的多条信息，但是这些用户信息不是在同一个页面上，例如我们看博客园里面的博客，每次查看如，

https://www.cnblogs.com/mlq2017/p/10054661.html /10054661这个值，换一篇博客，这个nid就会变，

1.通过GET方式实现：

#index.html

<body>

    <ul>

        {% for i,j in user_dict.items %}

        <li><a target="_blank" href="/detail/?nid={{ i }}">{{ j.name}}</a></li>

        {% endfor %}

    </ul>

</body>

#detail,html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <h1>详细信息</h1>

    <h3>用户名：{{ user_info.name }}</h3>

    <h3>年龄：{{ user_info.age }}</h3>

    <h3>邮箱：{{ user_info.email }}</h3>

</body>

</html>

#urls.py

path('index/', views.index),

path('detail/', views.detail),

#wiews.py

from django.shortcuts import render

USER_DICT = {

    "":{"name":"root1","age":"","email":"123@163.com"},

    "":{"name":"root2","age":"","email":"223@163.com"},

    "":{"name":"root3","age":"","email":"323@163.com"},

    "":{"name":"root4","age":"","email":"423@163.com"},

}

def detail(request): #通过GET,html里面用  /？+{{key}}

    a = request.GET.get("nid")

    user_info = USER_DICT[a]

    print(user_info)

    return render(request,"detail.html",{"user_info":user_info})

def index(request):

    return render(request,"index.html",{"user_dict":USER_DICT})

这里用到了如下方法：

1.html里面使用：href="/detail/?nid={{ i }}" 通过？加上字典的key跳转链接

2.views里面的detail里面通过GET获取nid: 然后通过nid获取字典的值，将值传给rengder（），再后在页面获取每个值中的信息

2.通过正则方式实现：

上面的HTML代码只有一个地方需要修改，做成动态匹配

{% for i,j in user_dict.items %}

        <li><a target="_blank" href="/detail-{{ i }}.html">{{ j.name }}</a></li>

        {% endfor %}

相应的urls.py里面用到正则匹配

from django.contrib import admin

from django.urls import path,re_path

from app import views

urlpatterns = [

    path('admin/', admin.site.urls),

    path('index/', views.index),

    re_path('detail-(\d+).html', views.detail),

]

既然我们用到正则，那这里就要导入正则，使用正则匹配

from django.urls import re_path
下面的匹配为：
re_path('detail-(\d+).html', views.detail),
这里要注意，之前的视频是很老的，方法不一样，按照视频上说的做，会一直报错

然后是views.py里面的修改了

def detail(request,nid):  #正则匹配

    #return HttpResponse(nid)

    user_info = USER_DICT[nid]

    print(nid)

    return render(request,"detail.html",{"user_info":user_info})

这里我们需要在detail里面再给一个形参，接收传过来的动态参数：这里返回的是字典的key,

然后通过nid直接获取字典的第一层值

建议使用正则的时候用下面的方法

re_path('detail-(?P<nid>\d+).html', views.detail),

将形参进行绑定，就不用考虑传入的位置

1.当html后面接很多-(\d+)时，如，re_path('detail-(\d+)-(\d+).html', views.detail),在detail里面传多个形式参数的时候def detail(request,nid,uid): 位置就要一一对应，

　　　　　　如果用上面的方式，我们就可以任意写形参的位置

2.当我们写正则的时候绑定了多个参数，在detail里面传多个形式参数的时候def detail(request,nid,uid，……):，我们就要穿多个参数，对于这样的，我们可以使用

def detail(request,*args,**kwargs):

这样，我们通过re_path('detail-(\d+)-(\d+).html', views.detail) 这样的就会把值传给*args

　　　我们通过re_path('detail-(?P<nid>\d+).html', views.detail),这样的就会吧值传给**kwargs

总结实战：

　　re_path('detail-(\d+)-(\d+).html', views.detail),

　　def func(request,nid,uid):

　　def func(request,*args):

　　args = (2,9)

　　def func(request,*args,**kwargs):

　　re_path('detail-(?P<nid>\d+)-(?P<nid>\d+).html', views.detail),

　　def func(request,nid,uid):

　　def func(request,*args,**kwargs):

　　*args为空，**kwargs为字典接受上面的值

三.关于url中的name

1.当频繁修改url，就要修改urls.py，又要修改html页面，

　　我们可以在urls里面给url进行绑定，之后无论怎么修改，只需要修改url里面的值就行

在绑定是添加name进行绑定
path('index/', views.index,name = "indexx"),

在detail.html里面，提交表单时，这么改

<form action="{% url "indexx" %}">

        <input type="text" />

    </form>

2.当我们还要在绑定的url后面继续使用匹配，如：path('index/(\d+)/', views.index,name = "indexx"),

　　此时我们无法通过action="{% url "indexx" %}" 进行提交，可以用

　　1.跳转到固定的页面

<form action="{% url "indexx" 11 %}">

　　后面这个11,表示只能跳转到这个页面，并且这种模板语言，后面只能写固定值

　　2.跳转到当前页面

　　　　这里要用到request中的path_info,获取当前页面的url

在detail函数里面，我们试着打印request.path_info

print(request.path_info) # 输出结果为：/detail-1.html

　　distail里面不需要改，因此我们可以在action里面这么写

<form action="{{ request.path_info }}">

用 path() 方法实现捕获参数

课上讲的是旧版本，现在Django已经2.0了，url()方法被path()方法替代，用法也有区别。
re_path() 可以看做是2.0里向下兼容的一个方法，也就是旧的1.0的 url() 方法。在2.0里用 path() 方法也可以实现捕获组的对应关系。使用 path() 方法需要注意：

要捕获一段url中的值，需要使用尖括号，而不是之前的圆括号；
可以转换捕获到的值为指定类型，比如int。默认情况下，捕获到的结果保存为字符串类型，不包含 '/' 这个特殊字符；
匹配模式的最开头不需要添加 '/' ，因为默认情况下，每个url都带一个最前面的 '/' ，既然大家都有的部分，就不用浪费时间特别写一个了。

 path('detail2-<int:nid>-<int:uid>.html', views.detail2),

上面的例子，就是捕获一个0或正整数，并且返回一个int类型，再用冒号把命名也完成了。除了int，还有下面这些。
默认情况下，Django内置下面的路径转换器：

str：匹配任何非空字符串，但不含斜杠/，如果你没有专门指定转换器，那么这个是默认使用的；
int：匹配0和正整数，返回一个int类型；
slug：可理解为注释、后缀、附属等概念，是url拖在最后的一部分解释性字符。该转换器匹配任何ASCII字符以及连接符和下划线，比如’ building-your-1st-django-site‘ ；
uuid：匹配一个uuid格式的对象。为了防止冲突，规定必须使用破折号，所有字母必须小写，例如’075194d3-6885-417e-a8a8-6c931e272f00‘ 。返回一个UUID对象；
path：匹配任何非空字符串，重点是可以包含路径分隔符’/‘。这个转换器可以帮助你匹配整个url而不是一段一段的url字符串。

小结

上面各种实现的方法由浅入深，并且一个比一个好，推荐用最后面的实现方式：

基于正则的url比使用get方式获取参数的好
命名捕获组比普通捕获组好
推荐还是用最后的 path() 方法来实现，如果是1.x的版本，那么就是推荐基于正则的命名捕获组的方法。

另外，在定义函数的时候也可以写成这种万能的模式： def detail2(request, *args, **kwargs): ，这样的话，要使用 args[0] （普通捕获组）或 kwargs['nid'] （命名捕获组）来取值。

路由分发

之前所有的url对应关系都写在了项目名下的urls里面，当我们的项目有多个app的时候，所有的页面都写在一起也不好。应该是每个app各自管理自己的那部分url。这就需要路由分发。

1.首先我们在项目名下的urls里面导入include,

from django.contrib import admin

from django.urls import path,re_path

from django.urls import include      #导入include

urlpatterns = [

    path('admin/', admin.site.urls),

    path('app/',include('app.urls'))   #添加app的绑定

]

　　　　如果有多个app，就继续在下面添加绑定 path('app1/',include('app1.urls')) 这样的

2.然后在app里面创建一个同样的urls.py

3.导入views,py

from django.urls import path,re_path

from app import views

urlpatterns = [

    path('index/', views.index),

]

默认值

命名空间

二、视图

提交数据不仅有POST和GET，还有其他的提交方法，比如：PUT、DELETE、HEAD、OPTION

form表单提交数据

1,request.POST.get()

2,request.GET.get()

3,request.POST.getlist()

4,request.FILES.get()

先上代码：

#login。html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="" method="post" enctype="multipart/form-data">

        <p>

            <input type="text" name="user" placeholder="用户名">

        </p>

        <p>

            <input type="password" name="pwd" placeholder="密码">

        </p>

        <p>

            男：<input type="radio" name="gender" value="">

            女：<input type="radio" name="gender" value="">

            人妖：<input type="radio" name="gender" value="">

        </p>

        <p>

            男：<input type="checkbox" name="favl" value="">

            女：<input type="checkbox" name="favl" value="">

            人妖：<input type="checkbox" name="favl" value="">

        </p>

        <p>

            <select name="city" multiple="multiple">

                <option  value="sz">深圳</option>

                <option value="bj">北京</option>

                <option value="sh">上海</option>

            </select>

        </p>

        <p>

            <input name="file" type="file">

        </p>

        <p>

            <input type="submit" value="提交">

            <span style="color: red">{{ error_msg }}</span>

        </p>

    </form>

</body>

</html>

views.py

from django.shortcuts import render,redirect,HttpResponse

# Create your views here.

def login(request):

    if request.method == "POST":

        obj = request.POST.get("gender")

        print("obj",obj) #输出为1

        obj1 = request.POST.get("favl")

        obj2 = request.POST.getlist("favl")

        print("obj1",obj1)  #这里checkbox是多选框，但是只获取到一个值，实际要获取多个，这里不能用get

        print("obj2", obj2)  #obj2 ['11', '33'] 这里获取到了每个选中的值

        obj3 = request.POST.getlist("city")

        print("obj3", obj3)  #obj3 ['sz', 'bj', 'sh']

        obj4 = request.POST.get("file")  #obj4 None <class 'NoneType'> 这里没获取到

        print("obj4", obj4,type(obj4))

        obj5 = request.FILES.get("file")

        print("obj5", obj5, type(obj5))  #这里获取到的是文件名和文件，

        #from django.core.files.uploadedfile import InMemoryUploadedFile

        f = open(obj5.name,"wb")

        for data in obj5.chunks():

            f.write(data)

        f.close()

    elif request.method == "GET":

        pass

    else:

        return HttpResponse("index")

    return render(request,"login.html",)

#error_msg = ""

# def login(request):

#     if request.method == "POST":

#         u = request.POST.get("user")

#         p = request.POST.get("pwd")

#         if u == 'aaa' and p == '123':

#             return HttpResponse("home")

#         else:

#             error_msg = "用户名或密码错误"

#             return render(request,"login.html",{"error_msg":error_msg})

#     elif request.method == "GET":

#         pass

#     else:

#         return HttpResponse("index")

#

#     return render(request,"login.html",)

#urls.py

from app import views

urlpatterns = [

    path('admin/', admin.site.urls),

    path('login/', views.login),

]

注释部分第一节已经写过，都是通过get获取

对于从网页只获取一个值的我们可以用get（text，password，radio）,

obj = request.POST.get("gender")

        print("obj",obj) #输出为1

但是如果是多选，就需要用getlist（checkbox,select）,

 obj1 = request.POST.get("favl")

        obj2 = request.POST.getlist("favl")

        print("obj1",obj1)  #这里checkbox是多选框，但是只获取到一个值，实际要获取多个，这里不能用get

        print("obj2", obj2)  #obj2 ['11', '33'] 这里获取到了每个选中的值

 obj3 = request.POST.getlist("city")

        print("obj3", obj3)  #obj3 ['sz', 'bj', 'sh']

普通表单无法上传文件，要上传文件，还需要在form标签中加 enctype="multipart/form-data"

另文件我们需要用request.FILES.get()，这样获取到的不是文件的名称，而是一个类，既能获取到文件名，又能获取到文件，文件名通过obj5.name获取，文件内容用 obj5.chunks()

obj4 = request.POST.get("file")  #obj4 None <class 'NoneType'> 这里没获取到

        print("obj4", obj4,type(obj4))

        obj5 = request.FILES.get("file")

        print("obj5", obj5, type(obj5))  #obj5 作业.png <class 'django.core.files.uploadedfile.InMemoryUploadedFile'>这里获取到的是文件名和文件，

        #from django.core.files.uploadedfile import InMemoryUploadedFile

        f = open(obj5.name,"wb")

        for data in obj5.chunks():

            f.write(data)

        f.close()

CBV 和 FBV

FBV（function base views）就是在视图里使用函数处理请求。
CBV（class base views）就是在视图里使用类处理请求。

到目前为止，所有的处理都是写在一个函数里的。Django还提供另外一个方式，我们也可以通过类来处理。

之前用FBV，这里也可以把之前的函数改成类处理请求，

#home.html

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="/home/" method="post">

        <input type="text" name="user" />

        <input type="submit" value="提交" />

    </form>

</body>

</html>

#views.py

from django.shortcuts import render,redirect,HttpResponse

#FBV和CBV

from django.views import View

class Home(View):

    def get(self,request):  #当输入http://127.0.0.1:8000/home/地址时，是get请求，因此下面的打印的结果为GET

        print(request.method)

        return render(request,"home.html")

    def post(self,request):

        print(request.method) #当输入内容时，是post请求，执行了这里，打印结果为POST

        return render(request,"home.html")

#urls.py

from app import views

urlpatterns = [

    path('admin/', admin.site.urls),

    #path('login/', views.login), 提交表单的

    path('home/', views.Home.as_view()),

]

以上代码执行和之前使用FBV效果是一样的，我们在类里写上对应的提交方式，当执行是，会自动到类里面去找对应的函数。

CBV的写法为

1.先导入View,在视图里面创建类

from django.views import View

class Home(View):

2.修改urls里面，这里添加url对应关系和FBV不同，应此需要特别注意：中间写上类名，后面固定跟一个 .as_view()

3.在类中定义相应的方法，

先去看看继承的View类里有什么，在源码的base.py这个文件里。首先里面定义了一个公有属性：

点击View会看到

http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace']

所以除了GET,POST，还可以处理这么多的请求方法，用起来，在类里照着别的一样定义一个同名方法就可以了。

3.在类中可以引入父类，就是Django内部定义的父类，这样我们既能定义自己的类，还可以继承父类，修改父类（装饰器）

继续看源码的View，调用了as_view()方法里面会再调用一个dispatch()方法。这个dispatch()方法里是通过映射获取我们的 request.method 即提交的方法来调用我们的处理方法的。dispatch()的源码如下：

    def dispatch(self, request, *args, **kwargs):

        # Try to dispatch to the right method; if a method doesn't exist,

        # defer to the error handler. Also defer to the error handler if the

        # request method isn't on the approved list.

        if request.method.lower() in self.http_method_names:

            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)

        else:

            handler = self.http_method_not_allowed

        return handler(request, *args, **kwargs)

结论就是，根据不同的请求类型提交到不同的处理方法，是用过dispatch()方法里通过映射来实现的。先执行dispatch()方法然后再调用对应的提交类型的处理方法。

class Home(View):

    def dispatch(self, request, *args, **kwargs):

        #调用父类中的dispatch

        result = super(Home,self).dispatch(request, *args, **kwargs)

        return result

    def get(self,request):  #当输入http://127.0.0.1:8000/home/地址时，是get请求，因此下面的打印的结果为GET

        print(request.method)

        return render(request,"home.html")

    def post(self,request):

        print(request.method) #当输入内容时，是post请求，执行了这里，打印结果为POST

        return render(request,"home.html")

在类中添加dispatch()方法后，执行效果和不添加它的效果是一样的

所以通过继承和重构dispatch()方法，可以在处理方法执行前和执行后自定义一些操作。如果需要的话就在我们的类里继承并重构，

    def dispatch(self, request, *args, **kwargs):

        #调用父类中的dispatch

        print("before")  //处理前执行的操作

        result = super(Home,self).dispatch(request, *args, **kwargs)

        print("after") //处理后执行的操作

        return result

上面看了View代码，我们看到了，当提交方式都不匹配的时候是执行下面的代码，页面是返回405

    def http_method_not_allowed(self, request, *args, **kwargs):

        logger.warning(

            'Method Not Allowed (%s): %s', request.method, request.path,

            extra={'status_code': 405, 'request': request}

        )

这里我们就可以重构自己的方法了：

def http_method_not_allowed(self, request, *args, **kwargs):

        return redirect('/home/')

给views.py分类

默认所有的处理函数都是写在views.py这个文件里的。如果处理函数很多，全部写在一个文件里也会很乱。这是可以考虑创建一个views包来替代原来的views.py文件。然后在views包里创建多个py文件来写我们的处理函数。比如：

views/account.py 是用户相关的操作，登录认证之类的
views/test.py 是用来测试的处理函数
views/order.py 订单相关的操作

三、模板

四、ORM操作

django数据库错误相关问题

连接sqlite数据库

默认使用的是sqlite3作为数据库，使用数据库需要一下步骤
一、创建你的数据库表结构

在app01里面的models.py添加类

from django.db import models

# Create your models here.

class Userinfo(models.Model):

    username = models.CharField(max_length=32);

    password = models.CharField(max_length=64);

上面的类等到去数据库创建表的时候，表名是 “app01_userinfo” ，也就是 [app名]_[类名] 。

二、设置settings.py文件
在 INSTALLED_APPS 注册你的app，把你的app追加到这个列表里：

INSTALLED_APPS = [

    'django.contrib.admin',

    'django.contrib.auth',

    'django.contrib.contenttypes',

    'django.contrib.sessions',

    'django.contrib.messages',

    'django.contrib.staticfiles',

    'app01.apps.AppConfig',

]

注：如果是在pycharm里面创建项目的时候创建的app，默认是已经加上了的；通过命令添加的，需要上面的操作：'app02.apps.AppConfig',

配置数据库连接，默认已经配置好了一个sqlite3，所以不需要修改：

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.sqlite3',

        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),

    }

}

三、去终端执行2条命令

python manage.py makemigrations

python manage.py migrate

第一条命令会在 app 目录下的 migrations 目录下创建一个文件（0001_initial.py），记录我们对 models.py 所做的变动。
第二条命令是真正去操作数据库了，除了创建我们自己写的表以外，还创建了很多 django 自己的表。
上面两条命令都是作用于全局的，如果要限定作用于只在某个app，可以在最后加上app的名称：

python manage.py makemigrations app01

python manage.py migrate app01

关于SQLite：

SQLite是一种嵌入式数据库，它的数据库就是一个文件。由于SQLite本身是C写的，而且体积很小，所以，经常被集成到各种应用程序中，甚至在iOS和Android的App中都可以集成。
Python就内置了SQLite3，所以，在Python中使用SQLite，不需要安装任何东西，直接使用。

使用SQLite

安装Navicat Premium 可以连接上SQLite

1.在pycharm里面右键点击SQLite，然后点击 copy path

2.打开Navicat Premium ，点击连接，选择SQlite，将C:\Users\ZYP\PycharmProjects\day19\db.sqlite3 复制到文件路径里面，给连接取个名字。用户名和密码不用填，点击连接

打开后，效果如下面截图

连接mysql

在settings里面设置如下：

DATABASES = {

    'default': {

    'ENGINE': 'django.db.backends.mysql',

    'NAME':'dbname',

    'USER': 'root',

    'PASSWORD': 'xxx',

    'HOST': '',

    'PORT': '',

    }

}

1

2

3

4

5

6

# 由于Django内部连接MySQL时使用的是MySQLdb模块，而python3中还无此模块，所以需要使用pymysql来代替

# 如下设置放置的与project同名的配置的 __init__.py文件中

import pymysql

pymysql.install_as_MySQLdb()

注：上面的数据库名，使用mysql时，需要自己手动创建

数据的增删改查

ORM操作

先添加如下代码：

#在APP01里面的urls.py里面

path("orm/", views.orm),

#views.py

from app01 import models

def orm(request):

    return HttpResponse("orm")

既然要操作数据库，这里肯定要导入models模块，表就用之前讲的userinfo

1.1添加数据，网页上输入http://127.0.0.1:8000/app01/orm/后，使用Navicat Premium 看下表里面的内容，此时已经添加了三条数据

    #添加数据

    for row in list:
　　　　list = [
    　　　　{"username": "root", "password": "admin"},
    　　　　{"username": "admin", "password": "admin"},
    　　　　{"username": "user", "password": "123456"},
　　　　　　]

        models.Userinfo.objects.create(username=row['username'],password=row["password"])

    return HttpResponse("ORM")

1.2添加数据

    # 第二种方法

     obj = models.Userinfo(username="root",password="")

     obj.save()

1.3添加数据

    # 第三种方法

    dic = {"username": "root", "password": "admin"}

    models.Userinfo.objects.create(**dic)

2.查询数据

    #查询数据all.filter

    result = models.Userinfo.objects.all() #查询所有

    result = models.Userinfo.objects.filter(username="root").all()   #while条件，查询指定的数据

    for i in result:

        print(i.id,i.username,i.password)

filter()里面还可以传入多个参数，就是多个条件，他们之间的关系是逻辑与（and）。

还有一个first()方法，取出第一个值，这样返回就不是列表而直接就是对象了。可以直接用，也可以用在filter()方法后面

models.UserInfo.objects.first()

models.UserInfo.objects.filter(username='root', password='').first()

# 上面就是一个验证用户登录的逻辑了，返回结果是None或者是找到的第一个对象

QuerySet 对象，分别打印出查询结果和这个对象的query属性：

res = models.UserInfo.objects.all()

print(res)  # 结果在下面

# <QuerySet [<UserInfo: UserInfo object (1)>, <UserInfo: UserInfo object (2)>, <UserInfo: UserInfo object (3)>]>

print(res.query)  # 结果写下面

# SELECT "cmdb_userinfo"."id", "cmdb_userinfo"."username", "cmdb_userinfo"."password" FROM "cmdb_userinfo

因此要看到对象的值，需要用for循环每个元素

3.删除数据

    #删数据 delete

     models.Userinfo.objects.filter(username="admin").delete()

4.修改数据

    #改数据update

    models.Userinfo.objects.filter(username="root").update(password = "")

后台管理实例

修改settings

#settings中的设置

MIDDLEWARE = [

    'django.middleware.security.SecurityMiddleware',

    'django.contrib.sessions.middleware.SessionMiddleware',

    'django.middleware.common.CommonMiddleware',

    #'django.middleware.csrf.CsrfViewMiddleware',

    'django.contrib.auth.middleware.AuthenticationMiddleware',

    'django.contrib.messages.middleware.MessageMiddleware',

    'django.middleware.clickjacking.XFrameOptionsMiddleware',

]

去掉注释的部分

绑定mysql

DATABASES = {

    'default': {

    'ENGINE': 'django.db.backends.mysql',

    'NAME':'testdb',

    'USER': 'root',

    'PASSWORD': 'root',

    'HOST': '127.0.0.1',

    'PORT': '',

    }

}

在总urls里面导入include

# 总urls.py

from django.contrib import admin

from django.urls import path

from django.urls import include

urlpatterns = [

    path('admin/', admin.site.urls),

    path('ORM/', include("ORM.urls")),

]

#orm中的urls

from django.urls import path,re_path

from ORM import views

urlpatterns = [

    path('login/', views.login),

    path('home/', views.home),

    path('user_info/', views.user_info),

    re_path('detail-(?P<nid>\d+)', views.detail),

]

mysql需要在项目名下的项目里面修改__init__

import pymysql

pymysql.install_as_MySQLdb()

添加三个页面

#login

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

</head>

<body>

    <form action="/ORM/login/" method="post" enctype="multipart/form-data">

        <p>

            <input type="text" name="user" placeholder="用户名">

        </p>

        <p>

            <input type="password" name="pwd" placeholder="密码">

        </p>

        <p>

            <input type="submit" value="提交">

            <span style="color: red">{{ error_msg }}</span>

        </p>

    </form>

</body>

</html>

#home

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <style>

        body{

            margin: 0 auto;

        }

        .head{

            height: 48px;

            background-color: #66c9f3;

        }

        .left{

            width: 200px;

            position: absolute;

            left: 0;

            top: 48px;

            bottom: 0;

            background-color: #dddddd;;

        }

        .menu{

            display: block;

            padding: 10px;

        }

        .right{

            background-color: #bce8f1;

            position: absolute;

            top: 48px;

            left: 200px;

            right: 0px;

            bottom: 0;

        }

    </style>

</head>

<body>

    <div class="head">后台管理系统</div>

    <div class="left">

        <a class="menu" href="/ORM/user_info/">用户管理</a>

        <a class="menu" href="/ORM/user_group/">用户组管理</a>

    </div>

    <div class="right"></div>

</body>

</html>

#user_info

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <style>

        body{

            margin: 0 auto;

        }

        .head{

            height: 48px;

            background-color: #66c9f3;

        }

        .left{

            width: 200px;

            position: absolute;

            left: 0;

            top: 48px;

            bottom: 0;

            background-color: #dddddd;;

        }

        .menu{

            display: block;

            padding: 10px;

        }

        .right{

            background-color: #bce8f1;

            position: absolute;

            top: 48px;

            left: 200px;

            right: 0px;

            bottom: 0;

        }

    </style>

</head>

<body>

    <div class="head">后台管理系统</div>

    <div class="left">

        <a class="menu" href="/ORM/user_info/">用户管理</a>

        <a class="menu" href="/ORM/user_group/">用户组管理</a>

    </div>

    <div class="right">

        <h3>用户列表</h3>

        <table border="1px">

            <thead>

                <tr>

                    <th>ID</th>

                    <th>用户名</th>

                </tr>

                {% for row in userlist%}

                    <tr>

                        <td><a href="/ORM/detail-{{row.id}}">{{row.id}}</a></td>

                        <td>{{row.username}}</td>

                    </tr>

                {% endfor %}

            </thead>

        </table>

    </div>

</body>

</html>

#detail

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>Title</title>

    <style>

        body{

            margin: 0 auto;

        }

        .head{

            height: 48px;

            background-color: #66c9f3;

        }

        .left{

            width: 200px;

            position: absolute;

            left: 0;

            top: 48px;

            bottom: 0;

            background-color: #dddddd;;

        }

        .menu{

            display: block;

            padding: 10px;

        }

        .right{

            background-color: #bce8f1;

            position: absolute;

            top: 48px;

            left: 200px;

            right: 0px;

            bottom: 0;

        }

    </style>

</head>

<body>

    <div class="head">后台管理系统</div>

    <div class="left">

        <a class="menu" href="/ORM/user_info/">用户管理</a>

        <a class="menu" href="/ORM/user_group/">用户组管理</a>

    </div>

    <div class="right">

        <h3>详细信息</h3>

        <h5>id:{{ user.id }}</h5>

        <h5>用户名：{{ user.username }}</h5>

        <h5>密码：{{ user.password }}</h5>

    </div>

</body>

</html>

models创建表

from django.db import models

# Create your models here.

class User(models.Model):

    username = models.CharField(max_length=16)

    password = models.CharField(max_length=32)

去终端执行2条命令

python manage.py makemigrations

python manage.py migrate

views主要代码：

from django.shortcuts import render,HttpResponse,redirect

from ORM import models

def initialized_db():

    USER = [

        {"username": "aaa", "password": ""},

        {"username": "bbb", "password": ""},

        {"username": "ccc", "password": ""},

        {"username": "ddd", "password": ""},

    ]

    find = models.User.objects.first()

    print("find",find)

    if find == None:

        for row in USER:

            models.User.objects.create(username =row["username"],password = row["password"])

initialized_db()

def login(request):

    error_msg = ""

    if request.method == "GET":

        return render(request,"login.html")

    elif request.method == "POST":

        user = request.POST.get("user",None)

        pwd = request.POST.get("pwd",None)

        result = models.User.objects.filter(username = user,password = pwd).first()

        #print(result)

        if result:

            return redirect("/ORM/home/")

        else:

            error_msg = "用户名或密码错误"

            return render(request,"login.html",{"error_msg":error_msg})

    else:

        return redirect("/login/")

def home(request):

    return render(request,"home.html")

def user_info(request):

    userlist = models.User.objects.all()

    #print(userlist.query)  #打印出来的是select语句

    return render(request,"user_info.html",{"userlist":userlist})

def detail(request,nid):

    a = models.User.objects.filter(id=nid)

    user = models.User.objects.filter(id = nid).first()  #这里要用first，否则就要用循环

    #print(type(a),type(user))   #<class 'django.db.models.query.QuerySet'> <class 'ORM.models.User'>

    return render(request,"detail.html",{"user":user})

增加用户信息

在页面上添加单条用户信息，并立即显示在页面上

#user_info 添加如下：

<h3>添加用户</h3>

        <form method="post" action="/ORM/user_info/">

            <input type="text" name = "user" placeholder="用户名" />

            <input type="password" name = "password" placeholder="密码" />

            <input type="submit" value="添加" />

        </form>

views.py 添加并修改如下：

def user_info(request):

    if request.method == "GET":

        userlist = models.User.objects.all()

        #print(userlist.query)  #打印出来的是select语句

        return render(request,"user_info.html",{"userlist":userlist})

    else:

        if request.method == "POST":

            username = request.POST.get("user")

            password = request.POST.get("password")

            models.User.objects.create(username = username,password = password)

            return redirect("/ORM/user_info/")

删除用户信息

修改user_info.html，

#直接修改表格，也可以再添加一列来放删除

<tr>

   <td><a href="/ORM/detail-{{row.id}}">{{row.id}}</a></td>

   <td>{{row.username}} |

       <a href="/ORM/dele-{{row.id}}">删除</a>

   </td>

</tr>

urls.py 添加如下：

re_path('dele-(?P<nid>\d+)', views.dele),

#views.py 添加如下

def dele(request,nid):

    models.User.objects.filter(id = nid).delete()

    return redirect("/ORM/user_info/")

修改用户信息

#继承home页面后，并修改右侧内容为

<div class="right">

        <h3>编辑用户信息</h3>

        <form action="user_edit-{{obj.id}}.html" method="post">

            <input style="display: none" type="text" name="id" value="{{obj.id}}"/>

            <input type="text" name="username" value="{{obj.username}}"/>

            <input type="text" name="password" value="{{obj.password}}"/>

            <input type="submit" value="提交"/>

        </form>

    </div>

#urls.py

 re_path('user_edit-(?P<nid>\d+)', views.user_edit),

#views.py

def user_edit(request,nid):

    if request.method == "GET":

        obj = models.User.objects.filter(id = nid).first()

        return render(request,"user_edit.html",{"obj":obj})

    else:

        if request.method == "POST":

            nid = request.POST.get("id")

            username = request.POST.get("username")

            password = request.POST.get("password")

            models.User.objects.filter(id = nid).update(username = username,password = password)

            return redirect("/ORM/user_info/")

注意：<form action="user_edit-{{obj.id}}.html" method="post"> 这里的写法

ORM表结构

修改表结构

1.修改过表结构之后，需要再执行一下下面的2行命令，把新的表结构应用到数据库。

python manage.py makemigrations

python manage.py migrate

2.修改数据长度：当修改数据长度比之前长的没什么影响，但是修改后的数据长度比之前短，就会造成数据丢失

3.删除一列，重新执行命令就后自动删掉了，没什么特别的

4.增加一列：当增加一列

# Create your models here.

class User(models.Model):

    username = models.CharField(max_length=16)

    password = models.CharField(max_length=32)

    email = models.CharField(max_length=32)

　　在终端执行第一条命令时，会提示，这是因为Django默认内容不能为空，这时你可以根据提示操作

　　1.在终端输入字符串作为默认值，然后再输入第二条命令

　　2.在新添加的一列后面添加null = True，此时表格新添加的一列就都可以为空了

　　　　email = models.CharField(max_length=32,null=True)

5.数据类型

　　基本数据类型：字符串，数字，时间，二进制

Django的ORM提供了非常多的字段类型，比如：EmailField、URLField、GenericIPAddressField。这些其实都是字符串类型而已，并且确实对我们没任何用（并不能帮我们做数据验证）。这些字段类型的只有在用Django的后台管理页面 admin 的时候才能发挥数据验证的效果。只有通过admin提交数据的时候才会验证你的数据格式是否正确。后面写怎么登录及哪里会显示格式错误

models对象的数据类型

AutoField(Field)

        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)

        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列

        from django.db import models

        class UserInfo(models.Model):

            # 自动创建一个列名为id的且为自增的整数列

            username = models.CharField(max_length=32)

        class Group(models.Model):

            # 自定义自增列

            nid = models.AutoField(primary_key=True)

            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):

        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)

        - 正小整数 0 ～ 32767

    IntegerField(Field)

        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)

        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):

        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    自定义无符号整数字段

        class UnsignedIntegerField(models.IntegerField):

            def db_type(self, connection):

                return 'integer UNSIGNED'

        PS: 返回值为字段在数据库中的属性，Django字段默认的值为：

            'AutoField': 'integer AUTO_INCREMENT',

            'BigAutoField': 'bigint AUTO_INCREMENT',

            'BinaryField': 'longblob',

            'BooleanField': 'bool',

            'CharField': 'varchar(%(max_length)s)',

            'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',

            'DateField': 'date',

            'DateTimeField': 'datetime',

            'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',

            'DurationField': 'bigint',

            'FileField': 'varchar(%(max_length)s)',

            'FilePathField': 'varchar(%(max_length)s)',

            'FloatField': 'double precision',

            'IntegerField': 'integer',

            'BigIntegerField': 'bigint',

            'IPAddressField': 'char(15)',

            'GenericIPAddressField': 'char(39)',

            'NullBooleanField': 'bool',

            'OneToOneField': 'integer',

            'PositiveIntegerField': 'integer UNSIGNED',

            'PositiveSmallIntegerField': 'smallint UNSIGNED',

            'SlugField': 'varchar(%(max_length)s)',

            'SmallIntegerField': 'smallint',

            'TextField': 'longtext',

            'TimeField': 'time',

            'UUIDField': 'char(32)',

    BooleanField(Field)

        - 布尔值类型

    NullBooleanField(Field):

        - 可以为空的布尔值

    CharField(Field)

        - 字符类型

        - 必须提供max_length参数， max_length表示字符长度

    TextField(Field)

        - 文本类型

    EmailField(CharField)：

        - 字符串类型，Django Admin以及ModelForm中提供验证机制

    GenericIPAddressField(Field)

        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6

        - 参数：

            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"

            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启刺功能，需要protocol="both"

    URLField(CharField)

        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)

        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)

        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)

        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)

        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能

        - 参数：

                path,                      文件夹路径

                match=None,                正则匹配

                recursive=False,           递归下面的文件夹

                allow_files=True,          允许文件

                allow_folders=False,       允许文件夹

    FileField(Field)

        - 字符串，路径保存在数据库，文件上传到指定目录

        - 参数：

            upload_to = ""      上传文件的保存路径

            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)

        - 字符串，路径保存在数据库，文件上传到指定目录

        - 参数：

            upload_to = ""      上传文件的保存路径

            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

            width_field=None,   上传图片的高度保存的数据库字段名（字符串）

            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)

        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]

    DateField(DateTimeCheckMixin, Field)

        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)

        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)

        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)

        - 浮点型

    DecimalField(Field)

        - 10进制小数

        - 参数：

            max_digits，小数总长度

            decimal_places，小数位长度

    BinaryField(Field)

        - 二进制类型

把主键拿出来说下

自增id，之前定义表结构的时候，省略了主键，让Django帮我创建了自增id。也可以自己定义主键和自增id：

id = models.AutoField(primary_key=True)，一定要加后面的     primary_key=True

class User(models.Model):

    id = models.AutoField(primary_key=True)  # 数据类型是自增，并且设为主键

    g = models.CharField(max_length=32)

6.字段的参数

null                数据库中字段是否可以为空

    db_column           数据库中字段的列名

    db_tablespace

    default             数据库中字段的默认值

    primary_key         数据库中字段是否为主键

    db_index            数据库中字段是否可以建立索引

    unique              数据库中字段是否可以建立唯一索引

    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引

    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引

    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称

    blank               Admin中是否允许用户输入为空

    editable            Admin中是否可以编辑

    help_text           Admin中该字段的提示信息

    choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作

                        如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

    error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；

                        字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date

                        如：{'null': "不能为空.", 'invalid': '格式错误'}

    validators          自定义错误验证（列表类型），从而定制想要的验证规则

                        from django.core.validators import RegexValidator

                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\

                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator

                        如：

                            test = models.CharField(

                                max_length=32,

                                error_messages={

                                    'c1': '优先错信息1',

                                    'c2': '优先错信息2',

                                    'c3': '优先错信息3',

                                },

                                validators=[

                                    RegexValidator(regex='root_\d+', message='错误了', code='c1'),

                                    RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),

                                    EmailValidator(message='又错误了', code='c3'), ]

                            )

参数

db_column ：数据库中字段的列名。默认列明就是我们的变量名，可以通过这个参数设置成不一样的　　

class UserInfo(models.Model):

    username = models.CharField(max_length=32)  # 列名就是变量名 username

    password = models.CharField(max_length=64, db_column='pwd')  # 数据库中的列名是 pwd

auto_now ：自动生成一个当前时间，数据更新时（包括创建），注意更新数据的写法，和前面的不同
auto_now_add ：自动生成一个当前时间，数据创建时

class UserInfo(models.Model):

    # 用户注册时会生成用户名和密码

    username = models.CharField(max_length=32)

    password = models.CharField(max_length=64)

    # 创建记录时会生成当前时间存放在ctime里，这个就是用户的注册时间

    ctime = models.DateTimeField(auto_now_add=True)

    # 用户修改密码会更新uptime的时间，这个就是上次修改密码的时间

    uptime = models.DateTimeField(auto_now=True)

#创建数据

# models.UserInfo.objects.filter(id=nid).update(password='1234') 这种方法更新是不会刷新 auto_now 的时间的

# 用save()方法更新可以刷新 auto_now 的时间

# obj =  models.UserInfo.objects.filter(id=nid).first()

# obj.password = '4321'

# obj.save()

choices ：Admin中显示选择框的内容。（用不变动的数据放在内存中从而避免连表操作，连表操作会涉及到性能问题）

class UserInfo(models.Model):

    username = models.CharField(max_length=32)

    password = models.CharField(max_length=64)

    # 用户有各种类型

    user_type_choices = (

        (1, '管理员')

        (2, '普通用户')

        (3, '访客')

    )

    # 定义一个用户类型的字段

    user_type_id = models.IntegerField(choices=user_type_choices, default=2)

# 这样数据库里是一个整数类型，值是1、2、3。使用字段名取值 obj.user_type_id 获取到的是数值

# 如果要获取后面的内容，使用 get_FOO_display() 方法， 即 obj.get_user_type_id_display()

# 但是我们在admin里看选择框的时候看到的是“管理员”、“普通用户”、“访客”，这就是因为把选项所对应的内容放到了内存中了

# 有了Django这个功能就不用再搞一张表，存放各个数值对应的内容了，还要做外键关联，用的时候还要连表查询

# 即使不用admin，我们也可以在自己的代码里读取这个属性获取到内容，避免连表查询

error_messages ：自定义错误信息（字典类型）。字典key：null、blank、invalid、invalid_choice、unique、unique_for_date

class UserInfo(models.Model):

    username = models.CharField(max_length=32)

    password = models.CharField(max_length=64, error_messages={'null': "不能为空", 'invalid': '格式错误'})

help_text ：Admin中该字段的提示信息。默认没有提示信息，设置后会显示在input框的下方

外键操作

一对多

创建外键关联-修改表结构

usergroup = models.ForeignKey(User_Group,on_delete=models.CASCADE,default=1)

ForeignKey创建外键

第一次创建的时候，我没有添加on_delete=models.CASCADE

在使用python manage.py makeigrations 进行迁移的时候的出错了，报错如下：

经过筛查，在创建多对一的关系的,需要在Foreign的第二参数中加入on_delete=models.CASCADE 主外关系键中，级联删除，也就是当删除主表的数据时候从表中的数据也随着一起删除

on_delete=models.CASCADE

default=1  设置外键默认值

外键关系创建完后，在user表里面会生成一列usergroup_id,并且生成了一个usergroup类

此时要查询usergroup表中的内容，在html中可以使用 {{row.usergroup.dept}}，row为views传过来的user表中所有对象

通过对象获取部门

Django基础--2的更多相关文章

Python之路-(js正则表达式、前端页面的模板套用、Django基础）
js正则表达式前端页面的模板套用 Django基础 js正则表达式: 1.定义正则表达式 /.../ 用于定义正则表达式 /.../g 表示全局匹配 /.../i 表示不区分大小写 /.../m ...
Django 基础教程
Django 基础教程这是第一篇 Django 简介 » Django 是由 Python 开发的一个免费的开源网站框架,可以用于快速搭建高性能,优雅的网站! 你一定可以学会,Django 很简单 ...
python的django基础篇
一.Django基础 Django 是用Python开发的一个免费开源的Web框架,可以用于快速搭建高性能,优雅的网站! Django的特点: 强大的数据库功能:拥有强大的数据库操作接口(QueryS ...
Python学习（二十六）—— Django基础一
转载自:http://www.cnblogs.com/liwenzhou/p/8258992.html 一.Web框架本质我们可以这样理解:所有的Web应用本质上就是一个socket服务端,而用户的 ...
Django基础(一)
Django基础(一) 知识预览 Django基本命令二路由配置系统(URLconf) 三编写视图四 Template 五数据库与ORM admin的配置一什么是web框架? 框架,即f ...
python3之Django基础篇
一.Django基础 Django 是用Python开发的一个免费开源的Web框架,可以用于快速搭建高性能,优雅的网站! Django的特点: 强大的数据库功能:拥有强大的数据库操作接口(QueryS ...
DJango 基础 (1)
django基础知识点: 基本认知工具准备新建项目目录及文件说明开发服务器创建视图函数新建应用(app) 1.基本认知 Django是用Python开发的一个免费开源的Web框架,可以用 ...
Django基础和基本使用
Django基础 Django是Python下的一款著名的Web框架框架任何语言进入到高级部分时,会有认证.session.http.连接数据库等等功能操作,没有框架时需要自己实现框架是整个或 ...
{Django基础十之Form和ModelForm组件}一 Form介绍二 Form常用字段和插件三 From所有内置字段四字段校验五 Hook钩子方法六进阶补充七 ModelForm
Django基础十之Form和ModelForm组件本节目录一 Form介绍二 Form常用字段和插件三 From所有内置字段四字段校验五 Hook钩子方法六进阶补充七 Model ...
{Django基础九之中间件} 一前戏二中间件介绍三自定义中间件四中间件的执行流程五中间件版登陆认证
Django基础九之中间件本节目录一前戏二中间件介绍三自定义中间件四中间件的执行流程五中间件版登陆认证六 xxx 七 xxx 八 xxx 一前戏我们在前面的课程中已经学会了 ...

随机推荐

[Groovy] Private fields and methods are not private in groovy
如题,, 具体介绍请参看: http://refaktor.blogspot.com/2012/07/private-fields-and-methods-are-not.html
Java 标准IO高可用类
输出: 使用: * <pre> * public class TestStdOut { * public static void main(String[] args) { * int a ...
CHUCK手把手带你搞定OPENSTACK
一.OpenStack初探 1.1 OpenStack简介 OpenStack是一整套开源软件项目的综合,它允许企业或服务提供者建立.运行自己的云计算和存储设施.Rackspace与NASA是最初重要 ...
PHP HTTP的PUT,DELETE的使用
GET操作是安全的.所谓安全是指不管进行多少次操作,资源的状态都不会改变.比如我用GET浏览文章,不管浏览多少次,那篇文章还在那,没有变化.当然,你可能说每浏览一次文章,文章的浏览数就加一,这不也改 ...
解决报错：import sun.misc.BASE64Decoder无法找到
解决报错:import sun.misc.BASE64Decoder无法找到 2017年09月29日 16:03:26 chaoyu168 阅读数:2116 标签: sun.misc.BASE64De ...
python模块之urllib
python文档官网地址:https://docs.python.org/3.6/library/urllib.html?highlight=urllib urllib 是一个收集以下模块以处理URL ...
c++中enum 如何使用(转)
ENUM概况 enum枚举类型是C/C++中的一种数据类型,与struct和class一样是用户自定义的类型,其特点在于enum类型的变量取值是有限的,是可以一一列举出来的. ENUM定义 C++ e ...
php数组·的方法1-数组统计函数
/** * 下面是数组统计函数 * * * **/ //count() 数组的长度 print_r(count($arr3)); echo '<hr>'; //max() min() 数组 ...
nginx 资源重定向
背景:有时候我一些资源(.js .css etc.)等不想访问我本地的,我想重定向到其他 URL 解决:直接修改 nginx 的配置文件 conf,添加下面的代码 #avoid processing ...
mysql 存储过程（代码块）
大纲: 创建.删除.调用. 声明变量.变量赋值声明游标声明异常处理器判断循环使用心得一.创建.删除.调用创建 DELIMITER $$ #修改分隔符 )) #括号里是入参.IN代表传入的 ...