python小白-day15 Django基础

时间  2019-11-17
标签 python day15 day django 基础 栏目 Python 繁體版
原文   原文链接

Python的WEB框架有Django、Tornado、Flask 等多种，Django相较与其余WEB框架其优点为：大而全，框架自己集成了ORM、模型绑定、模板引擎、缓存、Session等诸多功能。
css

django简介

Django是一个开放源代码的Web应用框架，由Python写成。采用了MVC的软件设计模式，即模型M，视图V和控制器C。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的，便是CMS（内容管理系统）软件。并于2005年7月在BSD许可证下发布。这套框架是以比利时的吉普赛爵士吉他手Django Reinhardt来命名的。html

Django是一个基于MVC构造的框架。可是在Django中，控制器接受用户输入的部分由框架自行处理，因此 Django 里更关注的是模型（Model）、模板(Template)和视图（Views），称为 MTV模式。它们各自的职责以下：python

模型（Model），即数据存取层linux

处理与数据相关的全部事务： 如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等。正则表达式

模板(Template)，即表现层sql

处理与表现相关的决定： 如何在页面或其余类型文档中进行显示。shell

视图（View），即业务逻辑层数据库

存取模型及调取恰当模板的相关逻辑。模型与模板之间的桥梁。django

基本结构：
json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
│  db.sqlite3 ----------sqlie3数据库
│  manage.py       
│     
├─logres
│  │  admin.py          后台，能够用不多量的代码就拥有一个强大的后台。
│  │  apps.py
│  │  models.py         与数据库操做相关，存入或读取数据时用到这个
│  │  tests.py
│  │  urls.py
│  │  views.py 
│  │  处理用户发出的请求，从urls.py中对应过来, 经过渲染templates中的网页能够将显示
│  │      内容好比登录后的用户名，用户请求的数据，输出到网页。
│  │  __init__.py
│  │ 
│  ├─migrations
│     │  0001_initial.py
│     │  __init__.py
│   
│ 
│ 
│ 
├─Mushishi
│  │  settings.py  Django 的设置，配置文件，好比 DEBUG 的开关，静态文件的位置等
│  │  urls.py    urls.py
│  │             网址入口，关联到对应的views.py中的一个函数（或者generic类），
│  │             访问网址就对应一个函数。
│  │  wsgi.py    wsgi有多重一种uwsgi和wsgi，你用那种wsgi来运行Django，
                  通常不用改只有你用到的时候在改
│  │  __init__.py
│  
│         
├─static
└─templates         templates中的Html模板，
         index.html
         login.html
         regist.html

安装django

1
2
3
4
5
6
7
8
9
10
1 .window 使用pycharm安装
     过程略
2 .window上使用pip安装
     pip install django
3 .linux下使用pip安装
     yum install python-pip
     pip install django= 1.9 . 5
4 .检查是否安装成功
>>> import django
>>> django.VERSION

基本命令

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
1 .建立django命令
django-admin.py startproject project-name（你工程的名字）
2 .建立django的app
python manage.py startapp app-name（你app的名字）
或 django-admin.py startapp app-name（你app的名字）
3 .同步数据库
python manage.py syncdb
注意：Django 1.7 . 1 及以上的版本须要用如下命令
python manage.py makemigrations
python manage.py migrate
4 .调试模式
python manage.py runserver 8001
#监听全部可用 ip （电脑可能有一个或多个内网ip，一个或多个外网ip，即有多个ip地址）
python manage.py runserver 0.0 . 0.0 : 8000
5 .清除数据库
python manage.py flush
6 .建立超级管理员
python manage.py createsuperuser
按照提示就ok
7 .修改管理员密码
python manage.py changepassword username（你当时设定的用户名）
8 .导入和导出数据
python manage.py dumpdata appname > appname.json
python manage.py loaddata appname.json
9 .进入数据库
python manage.py dbshell
10 .更多命令
python manage.py

建立django程序

1.建立一个project工程和app

步骤以下


Project和App概念

Project是一个大的工程，

下面有不少功能：（一个Project有多个App，其实他就是对你大的工程的一个分类）

例如一个运维平台是一个工程，那么他的app就是CMDB，监控系统，OA系统，

2.生成数据库 建立超级管理员用户

注：此步骤是在pycharm的终端里使用命令实现的

1
2
3
4
5
6
7
8
1 .同步数据库
python manage.py makemigrations
python manage.py migrate
本人使用的是django1. 9.5 版本
2 .建立超级管理员
python manage.py createsuperuser
3 .运行django
python manage.py runserver 8000

登陆页面：

1
2
浏览器访问：
http: //127.0.0.1:8000/admin/

3.路由

1.首先在helloword文件夹下（不是app目录，千万别写错）的urls.py填写路由规则

1
2
3
4
5
6
7
8
9
from django.conf.urls import url
from django.contrib import admin
#导入app下的view函数
from helloapp import  views
urlpatterns = [
url(r '^admin/' , admin.site.urls),
#当用户访问http://127.0.0.1：端口号的时候之间交给helloapp下面的views里的index函数来处理
url(r '^$' , views.index),
]

4.views函数

1.在helloapp（app）下面的views里写一个index函数

1
2
3
4
5
6
7
#Django 在返回的时候须要一层封装,须要导入HttpResponse
from django.shortcuts import render,HttpResponse
 
# Create your views here.
def index(request):
      #使用HttpRespons 封装返回信息
     return HttpResponse( '<h1>hello world!!!</h1>' )

django中的路由系统和其余语言的框架有所不一样，在django中每个请求的url都要有一条路由映射，这样才能将请求交给对一个的view中的函数去处理。其余大部分的Web框架则是对一类的url请求作一条路由映射，从而是路由系统变得简洁。

2.若是要返回html页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1. 在templates里建立index.html页面
内容：
 
<!DOCTYPE html>
<html lang = "en" >
<head>
<meta charset = "UTF-8" >
<title>Title< / title>
< / head>
<body>
<h1>Hello world!!< / h1>
< / body>
< / html>
2. 修改helloapp里的views.py的index函数
 
from django.shortcuts import render,HttpResponse
# Create your views here.
def index(request):
# return HttpResponse('<h1>hello world!!!</h1>')
return  render(request, 'index.html' )
#找到index.html
#读取index.html返回给用户

当以上步骤都完成以后，在IDE终端中输入：

1
python manage.py runserver 8000

访问：http://127.0.0.1:8000

django路由系统

在Django的urls中咱们能够根据一个URL对应一个函数名来定义路由规则以下：

每个urls对应一个views里的函数

1.基本的urls对应

1
2
3
4
5
urlpatterns = [
url(r '^login/$' , views.login),
url(r '^index/$' , views.index),
url(r '^$' , views.login),
]

2.基于app的路由

根据app对路由规则进行一次分类

当app的urls不少的时候，那么就不能再工程的urls下面去设置
应该这样设置：

1.首先在helloword下面的urls这样设置

1
2
3
4
5
6
7
8
9
10
11
#导入include
from django.conf.urls import url,include
from django.contrib import admin
#导入app下的view函数
from helloapp import  views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     #使用helloapp的urls规则
     url(r '^helloapp/' ,include( 'helloapp/urls' ))
 
]

2.在helloapp下面建立一个urls.py

内容：

1
2
3
4
5
6
7
8
9
10
11
from django.conf.urls import url,include
from django.contrib import admin
#导入app下的view函数
from . import views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     url(r '^login/' ,views.login),
     url(r '^index/' ,views.index),
     url(r '^reg/' ,views.reg),
     url(r '^layout/' ,views.layout),
]

3.在helloapp下面的views里建立上面urls对应的函数

1
2
3
4
5
6
7
8
9
10
11
from django.shortcuts import render,HttpResponse
# Create your views here.
def index(request):
     # return HttpResponse('<h1>hello world!!!</h1>')
     return  render(request, 'index.html' )
def login(request):
     return HttpResponse( 'login' )
def reg(request):
     return HttpResponse( 'reg' )
def layout(request):
     return HttpResponse( 'layout' )

4.访问：

1
2
3
4
5
http: //127.0.0.1:8000/helloapp/admin/ admin后台管理
http: //127.0.0.1:8000/helloapp/layout/
http: //127.0.0.1:8000/helloapp/login/
http: //127.0.0.1:8000/helloapp/reg/
http: //127.0.0.1:8000/helloapp/index/

3.动态路由（传一个参数）

好比分页：当urls大量过多的时候好比几百个的时候，那么确定不会去写几百个路由规则
全部这个时候就须要动态urls，使用正则表达式来完成

1.在helloapp下面的urls写入如下内容：

1
2
3
4
5
6
7
8
from django.conf.urls import url,include
from django.contrib import admin
#导入app下的view函数
from . import views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     url(r '^book/(\d+)$' , views.book), / / 正则匹配
]

2.在helloapp下面的views写入如下内容：

1
2
3
4
5
6
7
from django.shortcuts import render,HttpResponse
# Create your views here.
def book(request,num):
     print (num)
     return HttpResponse(num)
当用户访问http: / / 127.0 . 0.1 : 8000 / helloapp / book / 数字的时候
django会在自动把参数传给views里的book函数

3.测试访问：

1
2
3
4
5
6
7
http: / / 127.0 . 0.1 : 8000 / helloapp / book / 2
 
显示 2
 
http: / / 127.0 . 0.1 : 8000 / helloapp / book / 1
 
显示 1

4.动态路由（传多个参数）

多个参数它是已/来分割的

来一个url的加法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1. 在helloapp下面的urls写入如下内容：
 
from django.conf.urls import url,include
from django.contrib import admin
#导入app下的view函数
from . import views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     url(r '^book/(\d+)/(\d+)$' , views.book),
]
2. 在helloapp下面的views写入如下内容：
 
def book(request,num1,num2):
     print (num1,num2)
     num = int (num1) + int (num2)
     return HttpResponse(num)
3. 测试访问：
http: / / 127.0 . 0.1 : 8000 / helloapp / book / 2 / 1
显示 3
http: / / 127.0 . 0.1 : 8000 / helloapp / book / 2 / 10
显示 12

他的顺序是：正序的，你先给他传那个值，第一个参数就是那个

5.动态的路由（Key:value的形式）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
1. 在helloapp下面的urls写入如下内容：
 
from django.conf.urls import url,include
from django.contrib import admin
#导入app下的view函数
from . import views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     url(r '^book/(?P<k1>\d+)/(?P<k2>\d+)$' , views.book),
     这里?p<v1>这里的v1就是key，vlaue就是传进去的值,
]
2. 在helloapp下面的views写入如下内容：
 
from django.shortcuts import render,HttpResponse
# Create your views here.
def book(request,k1,k2):
     print (k1,k2)
     return HttpResponse(k1 + k2)

这样咱们就没必要按照顺序去取了，能够经过key，value的方式来取传进来的值

注：能够根据传来的值来进行判断返回给用户指定的url，过程略。

6.基于反射的动态路由

仅仅是经过反射来实现的，经过文件找到里面的函数而后执行！
可是在Django中不建议使用此方法。由于不一样的WEB框架建议你使用不一样的方式，
Django就不建议使用反射

模板引擎

django使用jinja2为模板引擎

使用方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
{{ item }}
{% for item in item_list %}  < a >{{ item }}</ a >  {% endfor %}
forloop.counter
forloop.first
forloop.last
{% if ordered_warranty %}  {% else %} {% endif %}
母板：{% block title %}{% endblock %}
子板：{% extends "base.html" %}
{% block title %}{% endblock %}
帮助方法：
{{ item.event_start|date:"Y-m-d H:i:s"}}
{{ bio|truncatewords:"30" }}
{{ my_list|first|upper }}
{{ name|lower }}

1.{item}

在helloapp下面的urls写入如下内容:

1
2
3
4
5
6
7
from django.conf.urls import url,include
from django.contrib import admin
from . import  views
urlpatterns = [
     url(r '^admin/' , admin.site.urls),
     url(r '^index/' ,views.index),
]

在helloapp下面views里面写入如下内容：

1
2
3
4
5
6
from django.shortcuts import render,HttpResponse
from django.shortcuts import redirect
# Create your views here.
def index(request):
     dic = { 'name' : 'hetan' , 'age' : '26' }
     return render(request, 'index.html' ,dic)

以后再index.html下面写入如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title >Title</ title >
</ head >
< body >
< div style = "background-color:red ;height: 100px" >
     < h1 >{{ name }}</ h1 >
     < h1 >{{ age }}</ h1 >
     < h1 >{{ job }}</ h1 >
</ div >
</ body >
</ html >

2.{% for item in item_list %} {{ item }} {% endfor %}

修改helloapp下面的views

1
2
3
4
5
6
from django.shortcuts import render,HttpResponse
from django.shortcuts import redirect
# Create your views here.
def index(request):
     dic = { 'userlist' :[ 'mayun' , 'alex' , 'wusir' , 'hetan' ]}
     return render(request, 'index.html' ,dic)

修改index.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<!DOCTYPE html>
< html lang = "en" >
< head >
     < meta charset = "UTF-8" >
     < title >Title</ title >
</ head >
< body >
< div style = "background-color:gray ;height:300px" >
     {% for item in userlist %}
     < h1 >{{ item }}</ h1 >
     {% endfor %}
</ div >
</ body >
</ html >

3.{% if ordered_warranty %} {% else %} {% endif %}

修改helloapp下面的views

1
2
3
4
5
6
from django.shortcuts import render,HttpResponse
from django.shortcuts import redirect
# Create your views here.
def index(request):
     dic = { 'user' : 'hetan' , 'age' : 26 }
     return render(request, 'index.html' ,dic)

修改index.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!DOCTYPE html>
< html lang = "en" >
< head >
     < meta charset = "UTF-8" >
     < title >Title</ title >
</ head >
< body >
< div style = "background-color:gray ;height:300px" >
     {% if user == 'hetan' %}
     < h1 >{{ user }}</ h1 >
     {% else %}
     < h1 >你输入的有问题</ h1 >
     {% endif %}
</ div >
</ body >
</ html >

4.母板和子板：

母版：{% block title %}{% endblock %}

子板：{% extends "base.html" %}


上面、左侧的红色框体都没有变，变得是中间的内容是怎么实现的呢？就是经过母版来实现

1.建立母板

在django里通常在templates里建立一个名字叫master的文件夹里存放母版的html页面
并且母版只有一个，不知道能不能多个母版，可是为了统一和使用因此只使用一个母版


master/mamaindex.html页面内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title >Title</ title >
< style >
     .header{
         height:100px;
         border: 1px solid rebeccapurple;
         background-color: #d3ffa4;
     }
     .header h1{
         display: block;
         margin-left:10px;
         font-size:50px;
     }
     .menu{
         background-color:dodgerblue;
         height:500px;;
         float: left;
         width: 20%;
         border: 1px solid black;
     }
     .menu ul{
         margin:0;
         padding: 0;
     }
     .menu ul li{
         list-style-type: none;
         width:100%;
         height:50px;
         background-color: aquamarine;
         border-bottom: 1px solid rebeccapurple;
 
     }
     .menu ul li a{
         font-size:20px;
         line-height:50px;
     }
     .content{
         background-color:slateblue;
         float: left;
         width:70%;
     }
</ style >
</ head >
< body >
< div class = "header" >< h1 >Hetan-django</ h1 ></ div >
     < div class = "menu" >
         < ul >
             < li >< a >菜单1</ a ></ li >
             < li >< a >菜单2</ a ></ li >
             < li >< a >菜单3</ a ></ li >
             < li >< a >菜单4</ a ></ li >
             < li >< a >菜单5</ a ></ li >
         </ ul >
     </ div >
     < div class = "content" >
         {#可变的子版内容,这个content和class content无关#}
         {% block content %} {% endblock %}
     </ div >
</ body >
</ html >

2.修改index.html（子板）

1
2
3
4
5
{% extends 'master/mamaindex.html' %}
 
{% block content %}
< h1 >这些一个变化的子板内容</ h1 >
{% endblock %}

5.导入公共标签
若是有公共的模板须要在不一样的html里使用。那么可使用导入公共的方式，避免重复代码

步骤：

在templates里
建立一个include目录（名字能够随意定义），放入公共的html页面

1.在include里新建一个inindex.html页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
< html lang = "en" >
< head >
     < meta charset = "UTF-8" >
     < title >Title</ title >
</ head >
< body >
< h1 >我是一个公共的内容</ h1 >
< form >
     < input type = "text" >
     < input type = "password" />
     < input  type = "button" />
</ form >
</ body >
</ html >

2.在index.html使用

1
2
3
4
5
6
{% extends 'master/mamaindex.html' %}
 
{% block content %}
< h1 >这些一个变化的子板内容</ h1 >
{% include 'include/inindex.html' %}
{% endblock %}

Django静态文件配置

把全部的静态都放在static目录下，好比：css、js、imgs、等


配置引入static目录，
在settings里,不然没法使用static目录下的静态文件，
由于他找不到路径！的须要告诉django

在公共配置文件settings中最后添加：

1
2
3
4
STATIC_URL = '/static/'
STATICFILES_DIRS = (
    os.path.join(BASE_DIR, 'static' ),
)

1.母版使用css，子板能够继承母版的css

2.首先在工程目录下建立static

3.在static里建立css目录用来存放css文件

4.在settings里配置static目录

5.在static目录下建立mama.css
放入一下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
.header{
         height:100px;
         border: 1px solid rebeccapurple;
         background-color: #d3ffa4;
     }
     .header h1{
         display: block;
         margin-left:10px;
         font-size:50px;
     }
     .menu{
         background-color:dodgerblue;
         height:500px;;
         float: left;
         width: 20%;
         border: 1px solid black;
     }
     .menu ul{
         margin:0;
         padding: 0;
     }
     .menu ul li{
         list-style-type: none;
         width:100%;
         height:50px;
         background-color: aquamarine;
         border-bottom: 1px solid rebeccapurple;
 
     }
     .menu ul li a{
         font-size:20px;
         line-height:50px;
     }
     .content{
         background-color:slateblue;
         float: left;
         width:70%;
     }

6.在templates里的master里的mamaindex.html（母版）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
#这个可让子板本身使用本身的title
< title >{% block title %}母版{% endblock %}</ title >
#引用css文件
< link rel = "stylesheet" href = "/static/css/mama.css" />
#而后在模板里,咱们也会写一个block,若是子版里有须要使用本身的css样式能够本身定义#}
#{% block css %} 内容 {% endblock %}
</ head >
< body >
< div class = "header" >< h1 >Yao-django</ h1 ></ div >
     < div class = "menu" >
         < ul >
             < li >< a >菜单1</ a ></ li >
             < li >< a >菜单2</ a ></ li >
             < li >< a >菜单3</ a ></ li >
             < li >< a >菜单4</ a ></ li >
             < li >< a >菜单5</ a ></ li >
         </ ul >
     </ div >
     < div class = "content" >
         {#可变的子版内容,这个content和class content无关#}
         {% block content %} {% endblock %}
     </ div >
</ body >
% block js %} 可使用本身的js {% endblock %}
</ html >

7.templates里的index.html写入如下内容:

1
2
3
4
5
6
{% extends 'master/mamaindex.html' %}
{% block title %}子板{% endblock %}
{% block content %}
< h1 >这些一个变化的子板内容</ h1 >
{% include 'include/inindex.html' %}   
{% endblock %}

django的Model基本操做和增、删、改、查

注：默认使用了sqlite3数据库

若是想使用其余数据库，请在settings里修改

1.建立数据库：

一、建立model类

在helloapp（或者你的app下）下models.py写入如下内容：

1
2
3
4
5
6
7
8
9
from django.db import models
# Create your models here.
#这个类是用来生成数据库表的,这个类必须集成models.Model
class UserInfo(models.Model):
     #建立表的字段
     username = models.CharField(max_length = 16 )
     #这个就表示去数据库建立一个字符串类型的字段
     password = models.CharField(max_length = 32 ) 
     #对于字符串类型的字段必须设置一个最大长度

2.注册app（若是没注册，那么不能建立数据库表）

1
请在settings里的INSTALLED_APPS里面加上你的app名字

3.建立数据库结构

在IDE终端输入：

1
2
python  manage.py makemigrations 生成一个数据库结构migrations里面一个表
python  manage.py migrate       根据migrations里面的表来建立数据库

4.为了方便查询,因此将数据库注册到后台。经过admin后台来管理

1
2
3
4
5
6
7
8
9
10
在helloapp下面的admin.py写入如下内容：
 
from django.contrib import admin
 
# Register your models here.
#导入helloapp的数据库模块
from . import models
 
#注册我们建立的类,经过他来访问
admin.site.register(models.UserInfo)

2.增长数据

使用页面来进行注册用户和密码插入数据库

1.插入一个urls在helloapp下面的urls.py

1
url(r '^reg/' ,views.reg),

2.在templates里面建立一个reg.html页面

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<!DOCTYPE html>
< html lang = "en" >
< head >
< meta charset = "UTF-8" >
< title >Title</ title >
</ head >
< body >
< form action = "/helloapp/reg/" method = "post" >
     < h1 >注册页面</ h1 >
     用户名：< input type = "text" />
     密 码：< input type = "password" />
     < input type = "submit" value = "注册" />
</ form >
</ body >
</ html >

3.在settings里注释中间件


4.在helloapp下的views里写入如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from django.shortcuts import render,HttpResponse
from django.shortcuts import redirect
#导入modles
from . import models
# Create your views here.
def index(request):
     dic = { 'user' : 'liuyao' , 'age' : 10 }
     return render(request, 'index.html' ,dic)
def reg(request):
     if request.method = = 'POST' :
         reg_user = request.POST[ 'username' ]
         reg_pwd = request.POST[ 'password' ]
         # 增长
         models.UserInfo.objects.create(username = reg_user, password = reg_pwd)
         # dic = {"username": 'hetan', "password": '123',}
         #models.UserInfo.objects.create(**dic)
         return  redirect( '/helloapp/index' )
     else :
         return render(request, 'reg.html' )
在后台管理能够看到此用户名和密码

3.删除

1
2
#根据条件删除
# models.UserInfo.objects.filter(username='yaoyao').delete()

4.修改

1
2
# 修改
# models.UserInfo.objects.all().update(age=18)

4.查询

1
2
3
4
5
6
7
8
9
10
#查找全部
# models.UserInfo.objects.all()
#查找指定条件
# models.UserInfo.objects.filter(age=18)
#查找第一个
# models.UserInfo.objects.filter(age=18).first()
#查找全部而且显示出来
# user_list_obj = models.UserInfo.objects.all()
# for line in user_list_obj:
#     print(line.username,line.age)





相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程