Py006-01-16关系型orm模型

实例：我们来假定下面这些概念，字段和关系

  1. 作者模型：一个作者有姓名和年龄。

  2. 作者详细模型：把作者的详情放到详情表，包含生日，手机号，家庭住址等信息。作者详情模型和作者模型之间是一对一的关系（one-to-one）

  3. 出版商模型：出版商有名称，所在城市以及email。

  4. 书籍模型： 书籍有书名和出版日期

    • 一本书只应该有一个出版商出版，所以出版商和书籍是一对多关联关系(one-to-many)

  5. 书籍作者关系表

    • 一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系(many-to-many);
      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
      # 出版社表
      create table publish(
          nid int primary key auto_increment,
          name varchar(32),
          city varchar(32),
          email varchar(32)
      );

      # 书籍表
      create table book(
          nid int primary key auto_increment,
          title varchar(32),
          publishDate date,
          price decimal(6,2),
          publish_id int,
          foreign key(publish_id) references publish(nid)
      );

      # 作者详情表
      create table authorDetail(
          nid int primary key auto_increment,
          birthday date ,
          telephone int,
          addr varchar(32)
      );

      # 作者表
      create table author(
          nid int primary key auto_increment,
          name varchar(32),
          age int,
          ad_id int unique,
          foreign key(ad_id) references authorDetail(nid)
      );

      # 书籍作者关系表
      create table book_authors(
          nid int primary key auto_increment,
          book_id int,
          author_id int,
          foreign key(book_id) references book(nid),
          foreign key(author_id) references author(nid)
      );

orm模型

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
64
65
66
67
from django.db import models

# 作者表
class Author(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    age=models.IntegerField()
    # 一对一  OneToOneField相当于指定 外间关联时设置  unique
    '''
    ad_id int unique,
    foreign key(ad_id) references authorDetail(nid)
    '''
    authordetail=models.OneToOneField(to="AuthorDetail",to_field="nid",on_delete=models.CASCADE)

# 作者详情表
class AuthorDetail(models.Model):
    nid = models.AutoField(primary_key=True)
    birthday=models.DateField()
    telephone=models.BigIntegerField()
    addr=models.CharField( max_length=64)

# 出版社表
class Publish(models.Model):
    nid = models.AutoField(primary_key=True)
    name=models.CharField( max_length=32)
    city=models.CharField( max_length=32)
    email=models.EmailField()

'''
Book  ----   Publish 一对多
'''
class Book(models.Model):
    nid = models.AutoField(primary_key=True)
    title = models.CharField( max_length=32)
    publishDate=models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2)



    # 一对多关系  一本书对应多个出版社
    publish=models.ForeignKey(to="Publish",to_field="nid",on_delete=models.CASCADE,)
    '''
        publish_id int,
        foreign key(publish_id) references publish(nid)

    '''

    #多对多
    authors =models.ManyToManyField(to="Author")

    '''
    # 书籍作者关系表
    create table book_authors(
        nid int primary key auto_increment,
        book_id int,
        author_id int,
        foreign key(book_id) references book(nid),
        foreign key(author_id) references author(nid)
    );
    '''

# 多对多关系时 不需要这个模型类   django会依据 authors =models.ManyToManyField(to="Author")帮我们生成这张表
# class Book2Author(models.Model):
#
#     nid = models.AutoField(primary_key=True)
#     book=models.ForeignKey(to="Book")
#     author=models.ForeignKey(to="Author")

生成表如下：





注意事项：

  • 表的名称myapp_modelName，是根据 模型中的元数据自动生成的，也可以覆写为别的名称　　
  • id 字段是自动添加的
  • 对于外键字段，Django 会在字段名上添加”_id” 来创建数据库中的列名
  • 这个例子中的CREATE TABLE SQL 语句使用PostgreSQL 语法格式，要注意的是Django 会根据settings 中指定的数据库类型来使用相应的SQL 语句。
  • 定义好模型之后，你需要告诉Django_使用_这些模型。你要做的就是修改配置文件中的INSTALL_APPSZ中设置，在其中添加models.py所在应用的名称。
  • 外键字段 ForeignKey 有一个 null=True 的设置(它允许外键接受空值 NULL)，你可以赋给它空值 None 。
  • 请务必设置on_delete=models.CASCADE(及联删除)否则会在django2报错on_delete。
  • 注意为什么authordetail=models.OneToOneField(to=”AuthorDetail”…)中AuthorDetail加引号
    如果AuthorDetail声明在Author前 可以不加但是如果定义在Author后就只能加引号来解决

添加表记录

操作前先简单的录入一些数据：

publish表

1
2
3
4
5
6
+-----+-----------------+--------+---------------+
| nid | name            | city   | email         |
+-----+-----------------+--------+---------------+
|   1 | 苹果出版社      | 北京   | 10000@qq.com  |
|   2 | 橘子出版社      | 天津   | 20000@126.com |
+-----+-----------------+--------+---------------+

author表

1
2
3
4
5
6
+-----+------+-----+-----------------+
| nid | name | age | authordetail_id |
+-----+------+-----+-----------------+
|   1 | alex |  33 |               1 |
|   2 | hjx  |  18 |               2 |
+-----+------+-----+-----------------+

authordetail表

1
2
3
4
5
6
+-----+------------+-----------+--------+
| nid | birthday   | telephone | addr   |
+-----+------------+-----------+--------+
|   1 | 1983-01-01 |       110 | 北京   |
|   2 | 2000-10-15 |       119 | 天津   |
+-----+------------+-----------+--------+

python代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
from django.shortcuts import render

# Create your views here.

from app01.models import Book,Publish,Author,AuthorDetail

def index(request):
    # 出版社记录
    Publish.objects.create(name='苹果出版社',city='北京',email='10000@qq.com')
    Publish.objects.create(name='橘子出版社', city='天津', email='20000@126.com')

    # 作者详情记录
    AuthorDetail.objects.create(birthday='1983-01-01',telephone=110,addr='北京')
    AuthorDetail.objects.create(birthday='2000-10-15', telephone=119, addr='天津')
    # 作者记录
    Author.objects.create(name='alex',age=33,authordetail_id=1)
    Author.objects.create(name='hjx', age=18, authordetail_id=2)

    return render(request,'index.html')

一对多

1
2
3
4
5
6
7
8
9
10
11
12
方式1:
   publish_obj=Publish.objects.get(nid=1)
   book_obj=Book.objects.create(title="金瓶梅",publishDate="2012-12-12",price=100,publish=publish_obj)
  
方式2:
   book_obj=Book.objects.create(title="金瓶梅",publishDate="2012-12-12",price=100,publish_id=1)


--------------------
查询金瓶梅对应出版社的邮箱
book_obj = Book.objects.filter(title='金瓶梅').first()
email = book_obj.publish.email
核心：book_obj.publish与book_obj.publish_id是什么？
1
2
3
4
5
+-----+-----------+-------------+--------+------------+
| nid | title     | publishDate | price  | publish_id |
+-----+-----------+-------------+--------+------------+
|   1 | 金瓶梅    | 2012-12-12  | 100.00 |          1 |
+-----+-----------+-------------+--------+------------+

多对多

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 当前生成的书籍对象
book_obj = Book.objects.create(title="追风筝的人", price=200, publishDate="2012-11-12", publish_id=1)
# 为书籍绑定的做作者对象
hjx = Author.objects.filter(name="hjx").first()  # 在Author表中主键为2的纪录
alex = Author.objects.filter(name="alex").first()  # 在Author表中主键为1的纪录

# 绑定多对多关系,即向关系表book_authors中添加纪录
book_obj.authors.add(hjx, alex)  # 将某些特定的 model 对象添加到被关联对象集合中。   
=======    book_obj.authors.add(*[])
'''
还可以这样  1,2代表作者的主键
book_obj.authors.add(1, 2)
还可以写出解包的形式
book_obj.authors.add(*[1,2])
'''
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
book表
+-----+-----------------+-------------+--------+------------+
| nid | title           | publishDate | price  | publish_id |
+-----+-----------------+-------------+--------+------------+
|   1 | 金瓶梅          | 2012-12-12  | 100.00 |          1 |
|   2 | 追风筝的人      | 2012-11-12  | 200.00 |          1 |
+-----+-----------------+-------------+--------+------------+

book_authors表
+----+---------+-----------+
| id | book_id | author_id |
+----+---------+-----------+
|  1 |       2 |         1 |
|  2 |       2 |         2 |
+----+---------+-----------+

核心:book_obj.authors.all()是什么？

多对多关系其它常用API：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
book_obj.authors.remove()      # 将某个特定的对象从被关联对象集合中去除。    ======   book_obj.authors.remove(*[])
book_obj.authors.clear()       #清空被关联对象集合
book_obj.authors.set()         #先清空再设置　
book_obj.authors.all()         #获取所有与这本书关联的作者对象的集合 queryset

'''
----------------操作实例
# 解除多多关系
book=Book.objects.filter(nid=2).first()
book.authors.remove(1) # 解除 主键为1的出版社
book.authors.remove(1,2) # 解除 主键为1，2的出版社
book.authors.remove(*[1,2]) # 解除 主键为1，2的出版社
book.authors.clear() # 解除所有关系


# 获取id为2d的书的所有关联作者集合
book.authors.all() # [obj1,obj2,...] queryset 
'''

more

Py006-01-15单表操作之CRUD

单表操作之查询

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
<1> all():                  查询所有结果
  
<2> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象
  
<3> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
                            如果符合筛选条件的对象超过一个或者没有都会抛出错误。
  
<4> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象
 
<5> order_by(*field):       对查询结果排序
  
<6> reverse():              对查询结果反向排序
  
<8> count():                返回数据库中匹配查询(QuerySet)的对象数量。
  
<9> first():                返回第一条记录
  
<10> last():                返回最后一条记录
  
<11> exists():              如果QuerySet包含数据，就返回True，否则返回False
 
<12> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
                            model的实例化对象，而是一个可迭代的字典序列
<13> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列
 
<14> distinct():            从返回结果中剔除重复纪录

自行拷贝上一节代码的结构

  • all() 查询所有记录
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
def index(request):
    # 添加表记录

    # 方式一
    # book_obj = Book(id=1,title='python红宝书',price=100,pub_date='2012-12-12',publish='人民出版社')
    # book_obj.save()


    # 方式二
    # book_obj2 = Book.objects.create(title='php',price=100,pub_date='2012-12-12',publish='人民出版社')
    # print(book_obj2.title)
    # print(book_obj2.publish)
    # return HttpResponse('hello')

    # 查询表记录

    book_list = Book.objects.all()
    print(book_list)

    return HttpResponse('ok')


# ---------------------------------------------------------
# 访问localhost:8000/index/
# pycharm里打印了这个
# <QuerySet [<Book: Book object (1)>, <Book: Book object (2)>]>

为什么打印的是个对象呢？

因为我们没有定义str方法

1
2
3
4
5
6
7
8
9
10
11
12
在模型models.py里添加 str方法
def __str__(self):
    return self.title


# 访问localhost:8000/index/
# pycharm里打印了这个
# <QuerySet [<Book: python红宝书>, <Book: php>]>
----------------------------------------------------
# QuerySet是啥？
类似一个列表放着一个个对象,也就是一行数据
[obj1,obj2,obj3]
  • 使用for循环来处理queryset
1
2
3
4
5
6
7
8
9
10
11
def index(request):
    ...
    # 查询表记录

    book_list = Book.objects.all()
    print(book_list)

    for item in book_list:
        print(item.title,item.price,item.publish)

    return HttpResponse('ok')
  • 取数据里第一个first，最后一个last

调用者queryset对象 返回值model对象

1
2
3
4
book = Book.objects.all().first()
book2 = Book.objects.all()[0]

book3 = Book.objects.all().last()
  • 过滤filter() 返回值：queryset对象
1
2
3
4
5
6
book_list = Book.objects.filter(price=100) # [obj1,obj2]

book = Book.objects.filter(price=100).first() # 取第一条记录

# -----------------支持多个条件
Book.objects.filter(price=100,title='php')
  • get() 只有——有且一个的情况下才有意义 返回值： model对象
1
2
3
4
5
book = Book.objects.get(price=100) # 两本书都一个价 报错

book2 = Book.objects.get(price=300) # 没有300元的书 报错

book3 = Book.objects.get(title='python红宝书')
  • exclude() 跟filter 相反，排除条件的结果，返回值 queryset
1
2
3
book1 = Book.objects.filter(title='php') # title='php' 的书

book1 = Book.objects.exclude(title='php') # title!='php' 的书
  • order_by() 排序 调用者：queryset 返回值：queryset
1
2
3
4
5
res = Book.objects.all().order_by("id") # 生序
res = Book.objects.all().order_by("-id") # 降序

# 按多列规则排序  如价格相同时 按书名排序
res = Book.objects.all().order_by("price",'title')
  • count() 计数 调用者：queryset 返回值：int类型

注意：count之后不能调用别的了因为返回值不是queryset了

1
res = Book.objects.all().count()
  • exist() 这张表里有没有记录
1
2
3
4
5
6
7
8
9
10
第一种方式  
res = Book.objects.all()
if res:
    print('有记录')
假如表里10万条记录，是不是很浪费

第二种
res = Book.objects.all().exist()
if res:
    print('有记录')

重要方法

  • values() 调用者：queryset 返回值：queryset

需求想查询所有书籍的名称

1
2
3
4
# 很麻烦要自己for循环处理
res = Book.objects.all()
for i in res:
    print(i.title)

解决方案——values() 单独取某个字段

1
2
3
4
5
6
7
8
9
10
11
12
13
res = Book.objects.all().values("price")

# <QuerySet [{'price': Decimal('100.00')}, {'price': Decimal('100.00')}]>

'''
原理
temp = []
for i in Book.objects.all():
    temp.append({
        "price":obj.price
    })
return temp
'''

其实也可以这样使用

1
2
3
Book.objects.values("price")

实际上是这个：Book.objects.all().values("price")

也可以获取多个字段 

1
Book.objects.all().values("price","title")

  • values_list() 调用者：queryset 返回值：queryset

1
2
3
4
5
6
7
8
9
10
11
12
跟 values调用方式一样
不同的是它们的返回内容

res = Book.objects.all().values_list("price")
# values_list 返回的内容是元祖形式
# <QuerySet [(Decimal('100.00'),), (Decimal('100.00'))]>



res = Book.objects.all().values("price")
# values 返回的内容是字典形式
# <QuerySet [{'price': Decimal('100.00')}, {'price': Decimal('100.00')}]>

  • distinct() 去重

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
table aa
----------------------
id      name        age
1       alex        12
2       alex        34

select distinct name from aa
-----
name
alex

select distinct id from aa
----- 没有任何意义因为id肯定不重复
id
1
2

----------------------------
res = Book.objects.all().distinct() # 没有一样 queryset里是一个个的对象

正确姿势 针对字段来使用 values()

1
res = Book.objects.all().values("price").distinct()

基于双下划线的模糊查询

注意filter里这样是错的

1
Book.objects.filter(price>100)

双下划线方法

  • 大于小于
1
2
3
Book.objects.filter(price__gt=100) # 价格大于100
Book.objects.filter(price__lt=100) # 价格小于100
Book.objects.filter(price__gt=100,price__lt=200) # 价格大于100小于200
  • 以什么开头
1
Book.objects.filter(title__startswith="py") # 以py开头
  • 包含指定内容
1
2
Book.objects.filter(title__contains="python") # 包含字符 python 不忽略大小写
Book.objects.filter(title__icontains="python") # 忽略大小写
  • 指定匹配几个值
1
Book.objects.filter(price__in=[100,200,300])
  • 范围
1
2
# 范围在 100-200
Book.objects.filter(price__range=[100,200])
  • 找日期范围 
1
2
3
4
5
# 发版日期在2012年的
Book.objects.filter(pub_date__year=2012)

# 发版日期在2012年6月的
Book.objects.filter(pub_date__year=2012,pub_date__year=6)

删除操作

  • delete() 调用者：queryset/model 返回值：元祖
1
2
3
4
5
6
7
# queryset调用删除
res = Book.objects.filter(price=100).delete()

print(res) # (2,{'app001.Book':2})

# model调用删除
Book.objects.filter(price=100).first().delete()

修改操作

  • update() 调用者：queryset
1
Book.objects.filter(title='php').update(title='php2')

实战练习

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1 查询xx出版社出版过的价格大于200的书籍

Book.objects.filter(publish='xx出版社',price__gt=200)

2 查询2017年8月出版的所有以py开头的书籍名称

Book.objects.filter(title__startswith='py',pub_date__year=2017,pub_date__month=8)
 
3 查询价格为50,100或者150的所有书籍名称及其出版社名称
 
Book.objects.filter(price__in=[50,100,150]).values('title','publist')

4 查询价格在100到200之间的所有书籍名称及其价格
 
Book.objects.filter(price__range=[100,200]).values('title','price')

5 查询所有xx出版社出版的书籍的价格（从高到低排序，去重）

Book.objects.filter(publish='xx出版社').values('price').distinct().order_by('-price')

Py006-01-14单表操作添加记录

单表操作之添加记录

本功能依赖上一节内容的项目结构

  • 1 models.py文件
1
2
3
4
5
6
7
8
9
from django.db import models


class Book(models.Model):
    id = models.AutoField(primary_key=True)
    title = models.CharField(max_length=32)
    pub_date = models.DateField()
    price = models.DecimalField(max_digits=8, decimal_places=2)
    publish = models.CharField(max_length=32)
  • 2 settings里添加mysql数据库配置,同时不要忘记在设置里注册app001
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
INSTALLED_APPS = [
    ...
    'app001'
]

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'orm',
        'USER':'root',
        'PASSWORD':'xxxx',
        'HOST':'127.0.0.1',
        'PORT':3306
    }
}
  • 3修改路由配置一个index视图函数
1
2
3
4
5
6
7
8
9
10
11
12
def index(request):
    # 添加表记录
    # 方式一
    # book_obj = Book(id=1,title='python红宝书',price=100,pub_date='2012-12-12',publish='人民出版社')
    # book_obj.save()


    # 方式二
    book_obj2 = Book.objects.create(title='php',price=100,pub_date='2012-12-12',publish='人民出版社')
    print(book_obj2.title)
    print(book_obj2.publish)
    return HttpResponse(book_obj2)

访问localhost:8000/index/

  • 第一种方式怎么刷新都只有一条记录(因为id定死了)
  • 第二种方式每次刷新都会新增一条记录

Py006-01-13单表操作生成模型

创建表

1.创建模型

创建名为app001的应用

修改app001/models.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from django.db import models

class Book(models.Model):
     id=models.AutoField(primary_key=True)
     title=models.CharField(max_length=32)
     pub_date=models.DateField()
     price=models.DecimalField(max_digits=8,decimal_places=2) # 999999.99
     publish=models.CharField(max_length=32) 


# 你想要自增长主键models.AutoField(primary_key=True)

# 你想要字符类型models.CharField(max_length=32)

# 你想要日期类型models.DateField()

# 你想要Decimal类型models.DecimalField(max_digits=8,decimal_places=2) # 999999.99

2.更多字段和参数

每个字段有一些特有的参数，例如，CharField需要max_length参数来指定VARCHAR数据库字段的大小。还有一些适用于所有字段的通用参数。 这些参数在文档中有详细定义，这里我们只简单介绍一些最常用的：

更多字段：(初次学习不要看这些更多内容，只有详细的业务场景才方便理解使用)

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
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
'''
 
<1> CharField
        字符串字段, 用于较短的字符串.
        CharField 要求必须有一个参数 maxlength, 用于从数据库层和Django校验层限制该字段所允许的最大字符数.
 
<2> IntegerField
       #用于保存一个整数.
 
<3> FloatField
        一个浮点数. 必须 提供两个参数:
         
        参数    描述
        max_digits    总位数(不包括小数点和符号)
        decimal_places    小数位数
                举例来说, 要保存最大值为 999 (小数点后保存2位),你要这样定义字段:
                 
                models.FloatField(..., max_digits=5, decimal_places=2)
                要保存最大值一百万(小数点后保存10位)的话,你要这样定义:
                 
                models.FloatField(..., max_digits=19, decimal_places=10)
                admin 用一个文本框(<input type="text">)表示该字段保存的数据.
 
<4> AutoField
        一个 IntegerField, 添加记录时它会自动增长. 你通常不需要直接使用这个字段;
        自定义一个主键：my_id=models.AutoField(primary_key=True)
        如果你不指定主键的话,系统会自动添加一个主键字段到你的 model.
 
<5> BooleanField
        A true/false field. admin 用 checkbox 来表示此类字段.
 
<6> TextField
        一个容量很大的文本字段.
        admin 用一个 <textarea> (文本区域)表示该字段数据.(一个多行编辑框).
 
<7> EmailField
        一个带有检查Email合法性的 CharField,不接受 maxlength 参数.
 
<8> DateField
        一个日期字段. 共有下列额外的可选参数:
        Argument    描述
        auto_now    当对象被保存时,自动将该字段的值设置为当前时间.通常用于表示 "last-modified" 时间戳.
        auto_now_add    当对象首次被创建时,自动将该字段的值设置为当前时间.通常用于表示对象创建时间.
        （仅仅在admin中有意义...)
 
<9> DateTimeField
         一个日期时间字段. 类似 DateField 支持同样的附加选项.
 
<10> ImageField
        类似 FileField, 不过要校验上传对象是否是一个合法图片.#它有两个可选参数:height_field和width_field,
        如果提供这两个参数,则图片将按提供的高度和宽度规格保存.    
<11> FileField
     一个文件上传字段.
     要求一个必须有的参数: upload_to, 一个用于保存上载文件的本地文件系统路径. 这个路径必须包含 strftime #formatting,
     该格式将被上载文件的 date/time
     替换(so that uploaded files don't fill up the given directory).
     admin 用一个<input type="file">部件表示该字段保存的数据(一个文件上传部件) .
 
     注意：在一个 model 中使用 FileField 或 ImageField 需要以下步骤:
            （1）在你的 settings 文件中, 定义一个完整路径给 MEDIA_ROOT 以便让 Django在此处保存上传文件.
            (出于性能考虑,这些文件并不保存到数据库.) 定义MEDIA_URL 作为该目录的公共 URL. 要确保该目录对
             WEB服务器用户帐号是可写的.
            （2） 在你的 model 中添加 FileField 或 ImageField, 并确保定义了 upload_to 选项,以告诉 Django
             使用 MEDIA_ROOT 的哪个子目录保存上传文件.你的数据库中要保存的只是文件的路径(相对于 MEDIA_ROOT).
             出于习惯你一定很想使用 Django 提供的 get_<#fieldname>_url 函数.举例来说,如果你的 ImageField
             叫作 mug_shot, 你就可以在模板中以 {{ object.#get_mug_shot_url }} 这样的方式得到图像的绝对路径.
 
<12> URLField
      用于保存 URL. 若 verify_exists 参数为 True (默认), 给定的 URL 会预先检查是否存在( 即URL是否被有效装入且
      没有返回404响应).
      admin 用一个 <input type="text"> 文本框表示该字段保存的数据(一个单行编辑框)
 
<13> NullBooleanField
       类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
       admin 用一个选择框 <select> (三个可选择的值: "Unknown", "Yes" 和 "No" ) 来表示这种字段数据.
 
<14> SlugField
       "Slug" 是一个报纸术语. slug 是某个东西的小小标记(短签), 只包含字母,数字,下划线和连字符.#它们通常用于URLs
       若你使用 Django 开发版本,你可以指定 maxlength. 若 maxlength 未指定, Django 会使用默认长度: 50.  #在
       以前的 Django 版本,没有任何办法改变50 这个长度.
       这暗示了 db_index=True.
       它接受一个额外的参数: prepopulate_from, which is a list of fields from which to auto-#populate
       the slug, via JavaScript,in the object's admin form: models.SlugField
       (prepopulate_from=("pre_name", "name"))prepopulate_from 不接受 DateTimeFields.
 
<13> XMLField
        一个校验值是否为合法XML的 TextField,必须提供参数: schema_path, 它是一个用来校验文本的 RelaxNG schema #的文件系统路径.
 
<14> FilePathField
        可选项目为某个特定目录下的文件名. 支持三个特殊的参数, 其中第一个是必须提供的.
        参数    描述
        path    必需参数. 一个目录的绝对文件系统路径. FilePathField 据此得到可选项目.
        Example: "/home/images".
        match    可选参数. 一个正则表达式, 作为一个字符串, FilePathField 将使用它过滤文件名. 
        注意这个正则表达式只会应用到 base filename 而不是
        路径全名. Example: "foo.*\.txt^", 将匹配文件 foo23.txt 却不匹配 bar.txt 或 foo23.gif.
        recursive可选参数.要么 True 要么 False. 默认值是 False. 是否包括 path 下面的全部子目录.
        这三个参数可以同时使用.
        match 仅应用于 base filename, 而不是路径全名. 那么,这个例子:
        FilePathField(path="/home/images", match="foo.*", recursive=True)
        ...会匹配 /home/images/foo.gif 而不匹配 /home/images/foo/bar.gif
 
<15> IPAddressField
        一个字符串形式的 IP 地址, (i.e. "24.124.1.30").
<16> CommaSeparatedIntegerField
        用于存放逗号分隔的整数值. 类似 CharField, 必须要有maxlength参数.
 
'''

更多参数：

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
1)null
 
如果为True，Django 将用NULL 来在数据库中存储空值。 默认值是 False.
 
(1)blank
 
如果为True，该字段允许不填。默认为False。
要注意，这与 null 不同。null纯粹是数据库范畴的，而 blank 是数据验证范畴的。
如果一个字段的blank=True，表单的验证将允许该字段是空值。如果字段的blank=False，该字段就是必填的。
 
(2)default
 
字段的默认值。可以是一个值或者可调用对象。如果可调用 ，每有新对象被创建它都会被调用。
 
(3)primary_key
 
如果为True，那么这个字段就是模型的主键。如果你没有指定任何一个字段的primary_key=True，
Django 就会自动添加一个IntegerField字段做为主键，所以除非你想覆盖默认的主键行为，
否则没必要设置任何一个字段的primary_key=True。
 
(4)unique
 
如果该值设置为 True, 这个数据字段的值在整张表中必须是唯一的
 
(5)choices
由二元组组成的一个可迭代对象（例如，列表或元组），用来给字段提供选择项。 如果设置了choices ，默认的表单将是一个选择框而不是标准的文本框，<br>而且这个选择框的选项就是choices 中的选项。

3settings配置

若想将模型转为mysql数据库中的表，需要在settings中配置：（默认是sqlite）

1
2
3
4
5
6
7
8
9
10
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME':'orm',     　　 　  # 要连接的数据库，连接前需要创建好
        'USER':'root',　　　　　　  # 连接数据库的用户名
        'PASSWORD':'',　　　　　　  # 连接数据库的密码
        'HOST':'127.0.0.1',       # 连接主机，默认本级
        'PORT':3306    　　　     #  端口 默认3306
    }
}

注意1：NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建 USER和PASSWORD分别是数据库的用户名和密码。设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。然后，启动项目，会报错：no module named MySQLdb 。这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb 对于py3有很大问题，所以我们需要的驱动是PyMySQL 所以，我们只需要找到项目名文件下的init,在里面写入：

1
2
import pymysql
pymysql.install_as_MySQLdb()

最后通过两条数据库迁移命令即可在指定的数据库中创建表 ：

1
2
3
4
# 初始化orm
python manage.py makemigrations
# 创建具体的表
python manage.py migrate

注意2:确保配置文件中的INSTALLED_APPS中写入我们创建的app名称

1
2
3
4
5
6
7
8
9
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    "app001" # 你的应用名
]

注意3:如果报错如下：

1
2
django.core.exceptions.ImproperlyConfigured: mysqlclient 1.3.3 or newer is required; you have 0.7.11.None
MySQLclient目前只支持到python3.4，因此如果使用的更高版本的python，需要修改如下：

通过查找路径C:\Programs\Python\Python36-32\Lib\site-packages\Django-2.0-py3.6.egg\django\db\backends\mysql
这个路径里的文件把

1
2
3
if version < (1, 3, 3):
     raise ImproperlyConfigured("mysqlclient 1.3.3 or newer is required; you have %s" % Database.__version__)
注释掉 就OK了。

注意4: 如果想打印orm转换过程中的sql，需要在settings中进行如下配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

Py006-01-12模型层orm理解

分层思想

  1. mysql安装在操作系统上
  2. pymysql实现python与 mysql的连接
  3. orm就是在pymysql之上连接数据库的操作

orm只能操作表级别，不能操作数据库

ORM简介

  • MVC或者MVC框架中包括一个重要的部分，就是ORM，它实现了数据模型与数据库的解耦，即数据模型的设计不需要依赖于特定的数据库，通过简单的配置就可以轻松更换数据库，这极大的减轻了开发人员的工作量，不需要面对因数据库变更而导致的无效劳动
  • ORM是“对象-关系-映射”的简称。

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
#sql中的表                                                      

 #创建表:
     CREATE TABLE employee(                                     
                id INT PRIMARY KEY auto_increment ,                    
                name VARCHAR (20),                                      
                gender BIT default 1,                                  
                birthday DATA ,                                         
                department VARCHAR (20),                                
                salary DECIMAL (8,2) unsigned,                          
              );


  #sql中的表纪录                                                  

  #添加一条表纪录:                                                          
      INSERT employee (name,gender,birthday,salary,department)            
             VALUES   ("alex",1,"1985-12-12",8000,"保洁部");               

  #查询一条表纪录:                                                           
      SELECT * FROM employee WHERE age=24;                               

  #更新一条表纪录:                                                           
      UPDATE employee SET birthday="1989-10-24" WHERE id=1;              

  #删除一条表纪录:                                                          
      DELETE FROM employee WHERE name="alex"                             





#python的类
class Employee(models.Model):
     id=models.AutoField(primary_key=True)
     name=models.CharField(max_length=32)
     gender=models.BooleanField()
     birthday=models.DateField()
     department=models.CharField(max_length=32)
     salary=models.DecimalField(max_digits=8,decimal_places=2)


 #python的类对象
      #添加一条表纪录:
          emp=Employee(name="alex",gender=True,birthday="1985-12-12",epartment="保洁部")
          emp.save()
      #查询一条表纪录:
          Employee.objects.filter(age=24)
      #更新一条表纪录:
          Employee.objects.filter(id=1).update(birthday="1989-10-24")
      #删除一条表纪录:
          Employee.objects.filter(name="alex").delete()

Py006-01-11django之模版语法继承

模版继承

Django模版引擎中最强大也是最复杂的部分就是模版继承了。模版继承可以让您创建一个基本的“骨架”模版，它包含您站点中的全部元素，并且可以定义能够被子模版覆盖的 blocks 。

自行建立一个django项目

  • 含有应用 app001
  • 视图函数 index
  • 视图模版 index.html

app001/urls.py

1
2
3
4
5
6
from app001 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    path(r'index/',views.index)
]

app001/views.py

1
2
def index(request):
    return render(request,'index.html')

index.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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        header{height: 50px;background: #369;}
        .left{background: #ddd;}
        .right{background: aqua}
    </style>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
<header></header>
<div class="container">
    <div class="row">
        <div class="col-md-3 left">
            <ol>
                <li>菜单1</li>
                <li>菜单2</li>
                <li>菜单3</li>
                <li>菜单4</li>
                <li>菜单5</li>
            </ol>
        </div>
        <div class="col-md-9 right">
            <ul>
                <li>1</li>
                <li>2</li>
                <li>3</li>
                <li>4</li>
                <li>5</li>
                <li>6</li>
                <li>7</li>
                <li>8</li>
                <li>9</li>
                <li>10</li>
            </ul>
        </div>
    </div>
</div>
</body>
</html>

需求想复用左侧的菜单列表

拷贝菜单这段代码，在templates下建立menu.html

1
2
3
4
5
6
7
<ol>
    <li>菜单1</li>
    <li>菜单2</li>
    <li>菜单3</li>
    <li>菜单4</li>
    <li>菜单5</li>
</ol>

修改index.html

1
2
3
4
5
6
7
8
9
10
11
12
13
<div class="col-md-3 left">
    <ol>
        <li>菜单1</li>
        <li>菜单2</li>
        <li>菜单3</li>
        <li>菜单4</li>
        <li>菜单5</li>
    </ol>
</div>
替换为
<div class="col-md-3 left">
    {% include 'menu.html' %}
</div>

需求现在有订单页order.html 想有index.html的 顶部的header和左边菜单

创建模版文件base.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
<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        header{height: 50px;background: #369;}
        .left{background: #ddd;}
        .right{background: aqua}
    </style>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css" integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
</head>
<body>
<header></header>
<div class="container">
    <div class="row">
        <div class="col-md-3 left">
            {% include 'menu.html' %}
        </div>
        <div class="col-md-9 right">
           {% block con %}
               <h1>默认显示内容</h1>
           {% endblock  %}
        </div>
    </div>
</div>
</body>
</html>

-----------------------------
{% block con %}
    
{% endblock  %}
是一个空盒子 等继承的人来填充内容

也可以设置默认内容
{% block con %}
    <h1>默认显示内容</h1>
{% endblock  %}
当继承模版的页面没有使用盒子就用这个默认的内容
使用了就覆盖掉这个默认的盒子

index.html

  • extends 标签是这里的关键。它告诉模版引擎，这个模版“继承”了另一个模版。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
{% extends 'base.html' %}

{% block con %}
<ul>
    <li>1</li>
    <li>2</li>
    <li>3</li>
    <li>4</li>
    <li>5</li>
    <li>6</li>
    <li>7</li>
    <li>8</li>
    <li>9</li>
    <li>10</li>
</ul>
{% endblock %}

注意事项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
- 如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其他的任何情况下，模版继承都将无法工作。

- 在base模版中设置越多的 {% block %} 标签越好。请记住，子模版不必定义全部父模版中的blocks，所以，你可以在大多数blocks中填充合理的默认内容，然后，只定义你需要的那一个。多一点钩子总比少一点好。

- 如果你发现你自己在大量的模版中复制内容，那可能意味着你应该把内容移动到父模版中的一个 {% block %} 中。

- If you need to get the content of the block from the parent template, the {{ block.super }} variable will do the trick. This is useful if you want to add to the contents of a parent block instead of completely overriding it. Data inserted using {{ block.super }} will not be automatically escaped (see the next section), since it was already escaped, if necessary, in the parent template.

- 为了更好的可读性，你也可以给你的 {% endblock %} 标签一个 名字 。例如：

{% block content %}
...
{% endblock content %}　　

在大型模版中，这个方法帮你清楚的看到哪一个　 {% block %} 标签被关闭了。

- 不能在一个模版中定义多个相同名字的 block 标签。

Py006-01-10django之自定义过滤器和标签

自定义标签和过滤器

1、在settings中的INSTALLED_APPS配置当前app，不然django无法找到自定义的simple_tag.

1
2
3
4
5
6
7
8
9
10
如你的应用是app001就在
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    "app001" #注册
]

2、在app中创建templatetags模块(模块名只能是templatetags)

3、创建任意 .py 文件，如：my_tags.py

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# 必须要引入这个模块
from django import template

#
register = template.Library()   #register的名字是固定的,不可改变
 
# 过滤器就加这个装饰器
@register.filter
def filter_multi(x,y):
    return  x * y

# 自定义标签就加这个装饰器
@register.simple_tag
def simple_tag_multi(x,y):
    return  x * y

@register.simple_tag
def my_input(id,arg):
    result = "<input type='text' id='%s' class='%s' />" %(id,arg,)
    return mark_safe(result)

4.使用自定义过滤器和标签必须load

index.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
{% load my_tag_filter %}
<p>{{ i|filter_multi:20}}</p>  ===> i=10  200 
# 过滤器最多接受一个参数
# 标签可以接受多个以空格分割
<p>{{simple_tag_multi:7 9}}</p>  ===>63


# 过滤器可以和if标签联合使用而 自定义标签和标签不能联合用
{% if i|filter_multi:10 > 100 %}
<p>100</p>
{% else %}
<p>{{ i }}</p>
{% endif %}

正常


{% if simple_tag_multi 9 10 > 100 %}
<p>100</p>
{% else %}
<p>{{ i }}</p>
{% endif %}

报错

Py006-01-09django之模版标签

标签

1
标签看起来像是这样的： {% tag %}。标签比变量更加复杂：一些在输出中创建文本，一些通过循环或逻辑来控制流程，一些加载其后的变量将使用到的额外信息到模版中。一些标签需要开始和结束标签 （例如{% tag %} ...标签 内容 ... {% endtag %}）。

for标签

  • 遍历每一个元素：
1
2
3
4
5
6
7
8
9
10
num_list = [1,2,3]
{% for i in num_list %}
    <p>{{ i }}</p>
{% endfor %}


person_list = [{"name":1},{"name":2}]
{% for person in person_list %}
    <p>{{ person.name }}</p>
{% endfor %}
1
可以利用{% for obj in list reversed %}反向完成循环。
  • 遍历一个字典：
1
2
3
4
5
{% for key,val in dic.items %}
    <p>{{ key }}:{{ val }}</p>
{% endfor %}

注：循环序号可以通过｛｛forloop｝｝显示
1
2
3
4
5
6
forloop.counter            The current iteration of the loop (1-indexed)
forloop.counter0           The current iteration of the loop (0-indexed)
forloop.revcounter         The number of iterations from the end of the loop (1-indexed)
forloop.revcounter0        The number of iterations from the end of the loop (0-indexed)
forloop.first              True if this is the first time through the loop
forloop.last               True if this is the last time through the loop

for … empty

1
for 标签带有一个可选的{% empty %} 从句，以便在给出的组是空的或者没有被找到时，可以有所操作。
1
2
3
4
5
6
7
arr = []
{% for i in arr %}
    <p>{{ i }}</p>

{% empty %}
    <p>暂无数据</p>
{% endfor %}

if 标签

1
{% if %}会对一个变量求值，如果它的值是“True”（存在、不为空、且不是boolean类型的false值），对应的内容块会输出。
1
2
3
4
5
6
7
{% if num > 100 or num < 0 %}
    <p>无效</p>
{% elif num > 80 and num < 100 %}
    <p>优秀</p>
{% else %}
    <p>凑活吧</p>
{% endif %}

with

使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

例如：

1
2
3
4
person_list = [{"name":"aaa"}]
{% with person_list.1.name as n %}
    {{ n }}  ===> "aaa"
{% endwith %}

csrf_token

这个标签用于跨站请求伪造保护

1
2
之前post请求出现403问题 
之前是修改settings里的 csrf注释掉

这个标签是另一种方案

index.html添加这个标签就不会报错了

1
2
3
4
5
6
<form action="" method="post">
    {{ csrf_token }}
    账号<input type="text" name="user">
    密码<input type="text" pwd="pwd">
    <input type="submit">
</form>

Py006-01-08django之模版

请自行建立一个django项目

  • 一个视图函数 index 渲染 render(request,’index.html’)

模版语法

1
2
3
- 变量：{{}} 双花括号
    1深度查询   句点符 .
- 标签 {% %}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def index(request):
    name = 'hjx'
    age = 18
    isMan = True
    num_list = [11, 22, 33]
    info = {"name": "hjx", "age": 18}

    class Person(object):
        def __init__(self, name, age):
            self.name = name
            self.age = age

    aa = Person("hjx", 18)
    bb = Person("alex", 98)
    person_list = [aa, bb]
    # 这样写每个值都要写一遍很麻烦
    # return render(request,"index.html",{"name":name,"age":age,"isMan":isMan,"num_list":num_list,"info":info,"aa":aa,"bb":bb,"person_list":person_list})
    # 使用locals
    return render(request,'index.html',locals())

index.html里取值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<p>{{ name }}</p>
<p>{{ age }}</p>
<p>{{ isMan }}</p>
<p>{{ num_list }}</p>
<p>{{ info }}</p>
<p>{{ aa }}</p>
<p>{{ bb }}</p>
<p>{{ person_list }}</p>

<hr>
深度查询
<p>{{ num_list.1 }}</p>
<p>{{ info.name }}</p>
<p>{{ aa.name }}</p>
<p>{{ bb.age }}</p>
<p>{{ person_list.1.name }}</p>

过滤器

语法规则

1
{{变量|过滤器名字:param}}
1
2
3
4
5
def index(request):
    import datetime
    now = datetime.now()
    arr = []
    return render(request,'index.html',locals())

index.html

1
2
3
{{now|date:"Y-m-d"}}   ===> "2018-10-11"
{{arr|default:"数据为空"}} ===> "数据为空"
{{arr|length}}  ===> 0

default

如果一个变量是false或者为空，使用给定的默认值。否则，使用变量的值。例如：

1
{{ value|default:"nothing" }}

length

返回值的长度。它对字符串和列表都起作用。例如：

1
2
{{ value|length }}
如果 value 是 ['a', 'b', 'c', 'd']，那么输出是 4。

filesizeformat

将值格式化为一个 “人类可读的” 文件尺寸 （例如 ‘13 KB’, ‘4.1 MB’, ‘102 bytes’, 等等）。例如：

1
2
{{ value|filesizeformat }}
如果 value 是 123456789，输出将会是 117.7 MB。

date

如果 value=datetime.datetime.now()

1
{{ value|date:"Y-m-d" }}

slice

如果 value=”hello world”

1
{{ value|slice:"2:-1" }}

truncatechars

如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“…”）结尾。

参数：要截断的字符数

例如：

1
{{ value|truncatechars:9 }}

truncatewords 按照单词截

safe

1
2
value="<a href="">点击</a>"
{{value}}  ===> 此时渲染出来不是a标签

Django的模板中会对HTML标签和JS等语法标签进行自动转义，原因显而易见，这样是为了安全。但是有的时候我们可能不希望这些HTML元素被转义，比如我们做一个内容管理系统，后台添加的文章中是经过修饰的，这些修饰可能是通过一个类似于FCKeditor编辑加注了HTML修饰符的文本，如果自动转义的话显示的就是保护HTML标签的源文件。为了在Django中关闭HTML的自动转义有两种方式，如果是一个单独的变量我们可以通过过滤器“|safe”的方式告诉Django这段代码是安全的不必转义。比如：

1
2
value="<a href="">点击</a>"
{{ value|safe}}

add

1
2
value = 1
{{value|add:100}}

upper

1
2
value = "a"
{{value|upper}} ===> A

Py006-01-07django之request和response

请求对象

前置工作准备项目

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
# step001
新建django项目  mydj004 设置应用名  app001
# step002 修改 mydj004/urls.py
from django.contrib import admin
from django.urls import path,re_path

from app001 import views

urlpatterns = [
    path('admin/', admin.site.urls),
    re_path(r'index/',views.index)
]

# step003 app001/views.py
from django.shortcuts import render,HttpResponse

def index(request):
    # 此处逻辑处理操作请求对象 request
    
    return render(request,"index.html")

# step004 template/index.html

<form action="" method="post">
    账号<input type="text" name="user">
    密码<input type="text" pwd="pwd">
    <input type="submit">
</form>

action什么都不写代表会拿当前url作为路径访问


# step005 去掉settings.py里的 csrf设置

 'django.middleware.csrf.CsrfViewMiddleware', 注释就好

# step006 打开 http://localhost:8000/index/ 准备工作完毕

request的一些内容

在视图函数里修改就可以了。。。

  • method
  • GET 将get请求参数封装在字典里
  • POST 将post请求参数封装在字典里
  • path 返回请求url的路径
1
2
3
4
5
6
7
8
9
10
11
12
13
14
def index(request):
    print('method', request.method)  # 打印请求的方式
    print(request.GET)  # 访问 http://localhost:8000/index/?name=1&pwd=2&name=22  {'name': ['1', '22'], 'pwd': ['2']}>
    print(request.POST) # http://localhost:8000/index/  提交表单内容 name=1 pwd=2  打印 {'name': ['1'], 'pwd': ['2']}>
    # 取字典的值
    name = request.GET.get("name")
    # 请求路径
    '''
    http://localhost:8000/index/?name=1&pwd=2
    url:协议://ip:port/路径?get请求数据
    '''
    print(request.path)
    
    return render(request,"index.html")

如果此时匹配 http://localhost:8000时访问 index.html

1
2
3
4
5
mydj004/urls.py里添加一个匹配规则
re_path(r'^$',views.index) 


# 此时 request.path打印  /

request常用方法

  • get_full_path() 跟path不同的是 同时携带get请求数据
  • is_ajax() 以后详细说 就是判断是不是ajax请求
1
2
3
# http://localhost:8000/index/?name=1&pwd=2
request.path ===> /index/
request.get_full_path() ===> /index/?name=1&pwd=2

request响应对象

对应视图函数里的 return

  • HttpResponse
  • render
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def index(request):
    return 响应内容

# 返回字符串  "OK"
return HttpResponse("OK")

# 返回h1标签
return HttpResponse("<h1>OK</h1>")


# render返回 templates里的页面
return render(request,"index.html")

# 可选参数 渲染变量 将视图函数里的数据渲染到页面里这时就要传递这个参数
import time
ctime = time.time()
return render(request,"index.html",{"timer":ctime})

修改index.html 添加个p标签
<p>{{ timer }}</p>

参考