Django学习笔记之数据库-模型的操作

zoukankan html css js c++ java

Django学习笔记之数据库-模型的操作
模型的操作

在ORM框架中，所有模型相关的操作，比如添加/删除等。其实都是映射到数据库中一条数据的操作。因此模型操作也就是数据库表中数据的操作。

添加模型

添加模型到数据库中。首先需要创建一个模型。创建模型的方式很简单，就跟创建普通的Python对象是一摸一样的。在创建完模型之后，需要调用模型的save方法，这样Django会自动的将这个模型转换成sql语句，然后存储到数据库中。示例代码如下：
```
class Book(models.Model):
    name = models.CharField(max_length=20,null=False)
    desc = models.CharField(max_length=100,name='description',db_column="description1")
    pub_date = models.DateTimeField(auto_now_add=True)

book = Book(name='三国演义',desc='三国英雄！')
book.save()
```
查找数据

查找数据都是通过模型下的objects对象来实现的。

查找所有数据

要查找Book这个模型对应的表下的所有数据。那么示例代码如下：
```
books = Book.objects.all()
```
以上将返回Book模型下的所有数据。

数据过滤

在查找数据的时候，有时候需要对一些数据进行过滤。那么这时候需要调用objects的filter方法。实例代码如下：
```
books = Book.objects.filter(name='三国演义')
> [<Book:三国演义>]

# 多个条件
books = Book.objects.filter(name='三国演义',desc='test')
```
调用filter，会将所有满足条件的模型对象都返回。

获取单个对象

使用filter返回的是所有满足条件的结果集。有时候如果只需要返回第一个满足条件的对象。那么可以使用get方法。示例代码如下：
```
book = Book.objects.get(name='三国演义')
> <Book:三国演义>
```
当然，如果使用get方法没有找到满足条件的对象的话，那么就会抛出一个异常。而filter在没有找到满足条件的数据的时候，是返回一个空的列表。

数据排序

在之前的例子中，数据都是无序的。如果你想在查找数据的时候使用某个字段来进行排序，那么可以使用order_by方法来实现。示例代码如下：
```
books = Book.objects.order_by("pub_date")
```
以上代码在提取所有书籍的数据的时候，将会使用pub_date从小到大进行排序。如果想要进行倒序排序，那么可以在pub_date前面加一个负号。实例代码如下：
```
books = Book.objects.order_by("-pub_date")
```
修改数据

在查找到数据后，便可以进行修改了。修改的方式非常简单，只需要将查找出来的对象的某个属性进行修改，然后再调用这个对象的save方法便可以进行修改。示例代码如下：
```
from datetime import datetime
book = Book.objects.get(name='三国演义')
book.pub_date = datetime.now()
book.save()
```
删除数据

在查找到数据后，便可以进行删除了。删除数据非常简单，只需要调用这个对象的delete方法即可。实例代码如下：
```
book = Book.objects.get(name='三国演义')
book.delete()
```
查询操作

查找是数据库操作中一个非常重要的技术。查询一般就是使用filter、exclude以及get三个方法来实现。我们可以在调用这些方法的时候传递不同的参数来实现查询需求。在ORM层面，这些查询条件都是使用field+__+condition的方式来使用的。以下将那些常用的查询条件来一一解释。

查询条件

1.exact

使用精确的=进行查找。如果提供的是一个None，那么在SQL层面就是被解释为NULL。示例代码如下：
```
article = Article.objects.get(id__exact=14)
article = Article.objects.get(id__exact=None)
```
以上的两个查找在翻译为SQL语句为如下：
```
select ... from article where id=14;
select ... from article where id IS NULL;
```
2.iexact

使用like进行查找。示例代码如下：
```
article = Article.objects.filter(title__iexact='hello world')
```
那么以上的查询就等价于以下的SQL语句：
```
select ... from article where title like 'hello world';
```
注意上面这个sql语句，因为在MySQL中，没有一个叫做ilike的。所以exact和iexact的区别实际上就是LIKE和=的区别，在大部分collation=utf8_general_ci情况下都是一样的（collation是用来对字符串比较的）。因此，实际开发中使用exact和iexact很少，直接使用：field=*** 即可。

3.contains

大小写敏感，判断某个字段是否包含了某个数据。示例代码如下：
```
articles = Article.objects.filter(title__contains='hello')
```
在翻译成SQL语句为如下：
```
select ... where title like binary '%hello%';
```
要注意的是，在使用contains的时候，翻译成的sql语句左右两边是有百分号的，意味着使用的是模糊查询。而exact翻译成sql语句左右两边是没有百分号的，意味着使用的是精确的查询。

4.icontains

大小写不敏感的匹配查询。示例代码如下：
```
articles = Article.objects.filter(title__icontains='hello')
```
在翻译成SQL语句为如下：
```
select ... where title like '%hello%';
```
5.in

提取那些给定的field的值是否在给定的容器中。容器可以为list、tuple或者任何一个可以迭代的对象，包括QuerySet对象。示例代码如下：
```
articles = Article.objects.filter(id__in=[1,2,3])
```
以上代码在翻译成SQL语句为如下：
```
select ... where id in (1,3,4)
```
当然也可以传递一个QuerySet对象进去。示例代码如下：
```
inner_qs = Article.objects.filter(title__contains='hello')
categories = Category.objects.filter(article__in=inner_qs)
```
以上代码的意思是获取那些文章标题包含hello的所有分类。
将翻译成以下SQL语句，示例代码如下：
```
select ...from category where article.id in (select id from article where title like '%hello%');
```
6.gt

某个field的值要大于给定的值。示例代码如下：
```
articles = Article.objects.filter(id__gt=4)
```
以上代码的意思是将所有id大于4的文章全部都找出来。
将翻译成以下SQL语句：
```
select ... where id > 4;
```
7.gte

类似于gt，是大于等于。

8.lt

类似于gt是小于。

9.lte

类似于lt，是小于等于。

10.startswith

判断某个字段的值是否是以某个值开始的。大小写敏感。示例代码如下：
```
articles = Article.objects.filter(title__startswith='hello')
```
以上代码的意思是提取所有标题以hello字符串开头的文章。
将翻译成以下SQL语句：
```
select ... where title like 'hello%'
```
11.istartswith

类似于startswith，但是大小写是不敏感的。

12.endswith

判断某个字段的值是否以某个值结束。大小写敏感。示例代码如下：
```
articles = Article.objects.filter(title__endswith='world')
```
以上代码的意思是提取所有标题以world结尾的文章。
将翻译成以下SQL语句：
```
select ... where title like '%world';
```
13.iendswith：

类似于endswith，只不过大小写不敏感。

14.range

判断某个field的值是否在给定的区间中。示例代码如下：
```
from django.utils.timezone import make_aware
from datetime import datetime
start_date = make_aware(datetime(year=2018,month=1,day=1))
end_date = make_aware(datetime(year=2018,month=3,day=29,hour=16))
articles = Article.objects.filter(pub_date__range=(start_date,end_date))
```
以上代码的意思是提取所有发布时间在2018/1/1到2018/12/12之间的文章。
将翻译成以下的SQL语句：
```
select ... from article where pub_time between '2018-01-01' and '2018-12-12'。
```
需要注意的是，以上提取数据，不会包含最后一个值。也就是不会包含2018/12/12的文章。
而且另外一个重点，因为我们在settings.py中指定了USE_TZ=True，并且设置了TIME_ZONE='Asia/Shanghai'，因此我们在提取数据的时候要使用django.utils.timezone.make_aware先将datetime.datetime从navie时间转换为aware时间。make_aware会将指定的时间转换为TIME_ZONE中指定的时区的时间。

15.date

针对某些date或者datetime类型的字段。可以指定date的范围。并且这个时间过滤，还可以使用链式调用。示例代码如下：
```
articles = Article.objects.filter(pub_date__date=date(2018,3,29))
```
以上代码的意思是查找时间为2018/3/29这一天发表的所有文章。
将翻译成以下的sql语句：
```
select ... WHERE DATE(CONVERT_TZ(`front_article`.`pub_date`, 'UTC', 'Asia/Shanghai')) = 2018-03-29
```
注意，因为默认情况下MySQL的表中是没有存储时区相关的信息的。因此我们需要下载一些时区表的文件，然后添加到Mysql的配置路径中。如果你用的是windows操作系统。那么在http://dev.mysql.com/downloads/timezones.html下载timezone_2018d_posix.zip - POSIX standard。然后将下载下来的所有文件拷贝到C:ProgramDataMySQLMySQL Server 5.7Datamysql中，如果提示文件名重复，那么选择覆盖即可。
如果用的是linux或者mac系统，那么在命令行中执行以下命令：mysql_tzinfo_to_sql /usr/share/zoneinfo | mysql -D mysql -u root -p，然后输入密码，从系统中加载时区文件更新到mysql中。

16.year

根据年份进行查找。示例代码如下：
```
articles = Article.objects.filter(pub_date__year=2018)
articles = Article.objects.filter(pub_date__year__gte=2017)
```
以上的代码在翻译成SQL语句为如下：
```
select ... where pub_date between '2018-01-01' and '2018-12-31';
select ... where pub_date >= '2017-01-01';
```
17.month

同year，根据月份进行查找。

18.day

同year，根据日期进行查找。

19.week_day

Django 1.11新增的查找方式。同year，根据星期几进行查找。1表示星期天，7表示星期六，2-6代表的是星期一到星期五。

20.time

根据时间进行查找。示例代码如下：
```
articles = Article.objects.filter(pub_date__time=datetime.time(12,12,12));
```
以上的代码是获取每一天中12点12分12秒发表的所有文章。
更多的关于时间的过滤，请参考Django官方文档：https://docs.djangoproject.com/en/2.0/ref/models/querysets/#range。

21.isnull

根据值是否为空进行查找。示例代码如下：
```
articles = Article.objects.filter(pub_date__isnull=False)
```
以上的代码的意思是获取所有发布日期不为空的文章。
将来翻译成SQL语句如下：
```
select ... where pub_date is not null;
```
22.regex和iregex

大小写敏感和大小写不敏感的正则表达式。示例代码如下：
```
articles = Article.objects.filter(title__regex=r'^hello')
```
以上代码的意思是提取所有标题以hello字符串开头的文章。
将翻译成以下的SQL语句：
```
select ... where title regexp binary '^hello';
```
iregex是大小写不敏感的。

根据关联的表进行查询

假如现在有两个ORM模型，一个是Article，一个是Category。代码如下：
```
class Category(models.Model):
    """文章分类表"""
    name = models.CharField(max_length=100)

class Article(models.Model):
    """文章表"""
    title = models.CharField(max_length=100,null=True)
    category = models.ForeignKey("Category",on_delete=models.CASCADE)
```
比如想要获取文章标题中包含"hello"的所有的分类。那么可以通过以下代码来实现：
```
categories = Category.object.filter(article__title__contains("hello"))
```
聚合函数

如果你用原生SQL，则可以使用聚合函数来提取数据。比如提取某个商品销售的数量，那么可以使用Count，如果想要知道商品销售的平均价格，那么可以使用Avg。
聚合函数是通过aggregate方法来实现的。在讲解这些聚合函数的用法的时候，都是基于以下的模型对象来实现的。
```
  from django.db import models

 class Author(models.Model):
     """作者模型"""
     name = models.CharField(max_length=100)
     age = models.IntegerField()
     email = models.EmailField()

     class Meta:
         db_table = 'author'


 class Publisher(models.Model):
     """出版社模型"""
     name = models.CharField(max_length=300)

     class Meta:
         db_table = 'publisher'


 class Book(models.Model):
     """图书模型"""
     name = models.CharField(max_length=300)
     pages = models.IntegerField()
     price = models.FloatField()
     rating = models.FloatField()
     author = models.ForeignKey(Author,on_delete=models.CASCADE)
     publisher = models.ForeignKey(Publisher, on_delete=models.CASCADE)

     class Meta:
         db_table = 'book'


 class BookOrder(models.Model):
     """图书订单模型"""
     book = models.ForeignKey("Book",on_delete=models.CASCADE)
     price = models.FloatField()

     class Meta:
         db_table = 'book_order'
```
聚合函数的基本方法

1.Avg

求平均值。比如想要获取所有图书的价格平均值。那么可以使用以下代码实现。
```
 from django.db.models import Avg
 result = Book.objects.aggregate(Avg('price'))
 print(result)
```
以上的打印结果是：
```
 {"price__avg":23.0}
```
其中price__avg的结构是根据field__avg规则构成的。如果想要修改默认的名字，那么可以将Avg赋值给一个关键字参数。示例代码如下：
```
 from django.db.models import Avg
 result = Book.objects.aggregate(my_avg=Avg('price'))
 print(result)
```
那么以上的结果打印为：
```
 {"my_avg":23}
```
2.Count

获取指定的对象的个数。示例代码如下：
```
 from django.db.models import Count
 result = Book.objects.aggregate(book_num=Count('id'))
```
以上的result将返回Book表中总共有多少本图书。
Count类中，还有另外一个参数叫做distinct，默认是等于False，如果是等于True，那么将去掉那些重复的值。比如要获取作者表中所有的不重复的邮箱总共有多少个，那么可以通过以下代码来实现：
```
     from djang.db.models import Count
     result = Author.objects.aggregate(count=Count('email',distinct=True))
```
3.Max和Min

获取指定对象的最大值和最小值。比如想要获取Author表中，最大的年龄和最小的年龄分别是多少。那么可以通过以下代码来实现：
```
 from django.db.models import Max,Min
 result = Author.objects.aggregate(Max('age'),Min('age'))
```
如果最大的年龄是88,最小的年龄是18。那么以上的result将为：
```
 {"age__max":88,"age__min":18}
```
4.Sum

求指定对象的总和。比如要求图书的销售总额。那么可以使用以下代码实现：
```
 from djang.db.models import Sum
 result = Book.objects.annotate(total=Sum("bookstore__price")).values("name","total")
```
以上的代码annotate的意思是给Book表在查询的时候添加一个字段叫做total，这个字段的数据来源是从BookStore模型的price的总和而来。values方法是只提取name和total两个字段的值。

更多的聚合函数请参考官方文档：https://docs.djangoproject.com/en/2.0/ref/models/querysets/#aggregation-functions

aggregate和annotate的区别
1. aggregate：返回使用聚合函数后的字段和值。
2. annotate：在原来模型字段的基础之上添加一个使用了聚合函数的字段，并且在使用聚合函数的时候，会使用当前这个模型的主键进行分组（group by）。
  比如以上Sum的例子，如果使用的是annotate，那么将在每条图书的数据上都添加一个字段叫做total，计算这本书的销售总额。
  而如果使用的是aggregate，那么将求所有图书的销售总额。
F表达式和Q表达式

F表达式

F表达式是用来优化ORM操作数据库的。比如我们要将公司所有员工的薪水都增加1000元，如果按照正常的流程，应该是先从数据库中提取所有的员工工资到Python内存中，然后使用Python代码在员工工资的基础之上增加1000元，最后再保存到数据库中。这里面涉及的流程就是，首先从数据库中提取数据到Python内存中，然后在Python内存中做完运算，之后再保存到数据库中。示例代码如下：
```
employees = Employee.objects.all()
for employee in employees:
    employee.salary += 1000
    employee.save()
```
而我们的F表达式就可以优化这个流程，他可以不需要先把数据从数据库中提取出来，计算完成后再保存回去，他可以直接执行SQL语句，就将员工的工资增加1000元。示例代码如下：
```
from djang.db.models import F
Employee.object.update(salary=F("salary")+1000)
```
F表达式并不会马上从数据库中获取数据，而是在生成SQL语句的时候，动态的获取传给F表达式的值。

比如如果想要获取作者中，name和email相同的作者数据。如果不使用F表达式，那么需要使用以下代码来完成：
```
    authors = Author.objects.all()
    for author in authors:
        if author.name == author.email:
            print(author)
```
如果使用F表达式，那么一行代码就可以搞定。示例代码如下：
```
    from django.db.models import F
    authors = Author.objects.filter(name=F("email"))
```
Q表达式

如果想要实现所有价格高于100元，并且评分达到9.0以上评分的图书。那么可以通过以下代码来实现：
```
books = Book.objects.filter(price__gte=100,rating__gte=9)
```
以上这个案例是一个并集查询，可以简单的通过传递多个条件进去来实现。
但是如果想要实现一些复杂的查询语句，比如要查询所有价格低于10元，或者是评分低于9分的图书。那就没有办法通过传递多个条件进去实现了。这时候就需要使用Q表达式来实现了。示例代码如下：
```
from django.db.models import Q
books = Book.objects.filter(Q(price__lte=10) | Q(rating__lte=9))
```
以上是进行或运算，当然还可以进行其他的运算，比如有&和~（非）等。一些用Q表达式的例子如下：
```
from django.db.models import Q
# 获取id等于3的图书
books = Book.objects.filter(Q(id=3))
# 获取id等于3，或者名字中包含文字"记"的图书
books = Book.objects.filter(Q(id=3)|Q(name__contains("记")))
# 获取价格大于100，并且书名中包含"记"的图书
books = Book.objects.filter(Q(price__gte=100)&Q(name__contains("记")))
# 获取书名包含“记”，但是id不等于3的图书
books = Book.objects.filter(Q(name__contains='记') & ~Q(id=3))
```
ORM模型迁移

迁移命令
1. makemigrations：将模型生成迁移脚本。模型所在的app，必须放在settings.py中的INSTALLED_APPS中。这个命令有以下几个常用选项：
  
  app_label：后面可以跟一个或者多个app，那么就只会针对这几个app生成迁移脚本。如果没有任何的app_label，那么会检查INSTALLED_APPS中所有的app下的模型，针对每一个app都生成响应的迁移脚本。
  
  --name：给这个迁移脚本指定一个名字。
  
  --empty：生成一个空的迁移脚本。如果你想写自己的迁移脚本，可以使用这个命令来实现一个空的文件，然后自己再在文件中写迁移脚本。
2. migrate：将新生成的迁移脚本。映射到数据库中。创建新的表或者修改表的结构。以下一些常用的选项：
  
  app_label：将某个app下的迁移脚本映射到数据库中。如果没有指定，那么会将所有在INSTALLED_APPS中的app下的模型都映射到数据库中。
  
  app_label migrationname：将某个app下指定名字的migration文件映射到数据库中。
  
  --fake：可以将指定的迁移脚本名字添加到数据库中。但是并不会把迁移脚本转换为SQL语句，修改数据库中的表。
  
  --fake-initial：将第一次生成的迁移文件版本号记录在数据库中。但并不会真正的执行迁移脚本。
3. showmigrations：查看某个app下的迁移文件。如果后面没有app，那么将查看INSTALLED_APPS中所有的迁移文件。
4. sqlmigrate：查看某个迁移文件在映射到数据库中的时候，转换的SQL语句。
migrations中的迁移版本和数据库中的迁移版本对不上怎么办？
1. 找到哪里不一致，然后使用python manage.py --fake [版本名字]，将这个版本标记为已经映射。
2. 删除指定app下migrations和数据库表django_migrations中和这个app相关的版本号，然后将模型中的字段和数据库中的字段保持一致，再使用命令python manage.py makemigrations重新生成一个初始化的迁移脚本，之后再使用命令python manage.py makemigrations --fake-initial来将这个初始化的迁移脚本标记为已经映射。以后再修改就没有问题了。
更多关于迁移脚本的。请查看官方文档：https://docs.djangoproject.com/en/2.0/topics/migrations/

根据已有的表自动生成模型

在实际开发中，有些时候可能数据库已经存在了。如果我们用Django来开发一个网站，读取的是之前已经存在的数据库中的数据。那么该如何将模型与数据库中的表映射呢？根据旧的数据库生成对应的ORM模型，需要以下几个步骤：
1. Django给我们提供了一个inspectdb的命令，可以非常方便的将已经存在的表，自动的生成模型。想要使用inspectdb自动将表生成模型。首先需要在settings.py中配置好数据库相关信息。不然就找不到数据库。示例代码如下：
  
  DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': "migrations_demo", 'HOST': '127.0.0.1', 'PORT': '3306', 'USER': 'root', 'PASSWORD': 'root' } }
  
  比如有以下表：
  
  article表：
  ![img](file:///E:/qq/446516214/FileRecv/%E7%9F%A5%E4%BA%86%E8%AF%BE%E4%BB%B6/%E7%9F%A5%E4%BA%86%E8%AF%BE%E5%A0%82Django%E8%AF%BE%E4%BB%B6/django-advance/assets/article%E8%A1%A8.png)
  
  tag表：
  ![img](file:///E:/qq/446516214/FileRecv/%E7%9F%A5%E4%BA%86%E8%AF%BE%E4%BB%B6/%E7%9F%A5%E4%BA%86%E8%AF%BE%E5%A0%82Django%E8%AF%BE%E4%BB%B6/django-advance/assets/tag%E8%A1%A8.png)
  
  article_tag表：
  ![img](file:///E:/qq/446516214/FileRecv/%E7%9F%A5%E4%BA%86%E8%AF%BE%E4%BB%B6/%E7%9F%A5%E4%BA%86%E8%AF%BE%E5%A0%82Django%E8%AF%BE%E4%BB%B6/django-advance/assets/article_tag%E8%A1%A8.png)
  
  front_user表：
  ![img](file:///E:/qq/446516214/FileRecv/%E7%9F%A5%E4%BA%86%E8%AF%BE%E4%BB%B6/%E7%9F%A5%E4%BA%86%E8%AF%BE%E5%A0%82Django%E8%AF%BE%E4%BB%B6/django-advance/assets/frontuser.png)
  
  那么通过python manage.py inspectdb，就会将表转换为模型后的代码，显示在终端：
  
  from django.db import models class ArticleArticle(models.Model): title = models.CharField(max_length=100) content = models.TextField(blank=True, null=True) create_time = models.DateTimeField(blank=True, null=True) author = models.ForeignKey('FrontUserFrontuser', models.DO_NOTHING, blank=True, null=True) class Meta: managed = False db_table = 'article_article' class ArticleArticleTags(models.Model): article = models.ForeignKey(ArticleArticle, models.DO_NOTHING) tag = models.ForeignKey('ArticleTag', models.DO_NOTHING) class Meta: managed = False db_table = 'article_article_tags' unique_together = (('article', 'tag'),) class ArticleTag(models.Model): name = models.CharField(max_length=100) class Meta: managed = False db_table = 'article_tag' class FrontUserFrontuser(models.Model): username = models.CharField(max_length=100) telephone = models.CharField(max_length=11) class Meta: managed = False db_table = 'front_user_frontuser'
  
  以上代码只是显示在终端。如果想要保存到文件中。那么可以使用>重定向输出到指定的文件。比如让他输出到models.py文件中。示例命令如下：
  
  python manage.py inspectdb > models.py
  
  以上的命令，只能在终端执行，不能在pycharm->Tools->Run manage.py Task...中使用。
  
  如果只是想要转换一个表为模型。那么可以指定表的名字。示例命令如下：
  
  python manage.py inspectdb article_article > models.py
2. 修正模型：新生成的ORM模型有些地方可能不太适合使用。比如模型的名字，表之间的关系等等。那么以下选项还需要重新配置一下：
  
  模型名：自动生成的模型，是根据表的名字生成的，可能不是你想要的。这时候模型的名字你可以改成任何你想要的。
  
  模型所属app：根据自己的需要，将相应的模型放在对应的app中。放在同一个app中也是没有任何问题的。只是不方便管理。
  
  模型外键引用：将所有使用ForeignKey的地方，模型引用都改成字符串。这样不会产生模型顺序的问题。另外，如果引用的模型已经移动到其他的app中了，那么还要加上这个app的前缀。
  
  让Django管理模型：将Meta下的managed=False删掉，如果保留这个，那么以后这个模型有任何的修改，使用migrate都不会映射到数据库中。
  
  当有多对多的时候，应该也要修正模型。将中间表注视了，然后使用ManyToManyField来实现多对多。并且，使用ManyToManyField生成的中间表的名字可能和数据库中那个中间表的名字不一致，这时候肯定就不能正常连接了。那么可以通过db_table来指定中间表的名字。示例代码如下：
  
  class Article(models.Model): title = models.CharField(max_length=100, blank=True, null=True) content = models.TextField(blank=True, null=True) author = models.ForeignKey('front.User', models.SET_NULL, blank=True, null=True) # 使用ManyToManyField模型到表，生成的中间表的规则是：article_tags # 但现在已经存在的表的名字叫做：article_tag # 可以使用db_table，指定中间表的名字 tags = models.ManyToManyField("Tag",db_table='article_tag') class Meta: db_table = 'article'
  
  表名：切记不要修改表的名字。不然映射到数据库中，会发生找不到对应表的错误。
3. 执行命令python manage.py makemigrations生成初始化的迁移脚本。方便后面通过ORM来管理表。这时候还需要执行命令python manage.py migrate --fake-initial，因为如果不使用--fake-initial，那么会将迁移脚本会映射到数据库中。这时候迁移脚本会新创建表，而这个表之前是已经存在了的，所以肯定会报错。此时我们只要将这个0001-initial的状态修改为已经映射，而不真正执行映射，下次再migrate的时候，就会忽略他。
4. 将Django的核心表映射到数据库中：Django中还有一些核心的表也是需要创建的。不然有些功能是用不了的。比如auth相关表。如果这个数据库之前就是使用Django开发的，那么这些表就已经存在了。可以不用管了。如果之前这个数据库不是使用Django开发的，那么应该使用migrate命令将Django中的核心模型映射到数据库中。
查看全文

相关阅读:
程序清单 8-8 exec函数实例，a.out是程序8-9产生的可执行程序
 程序清单8-9 回送所有命令行参数和所有环境字符串
 程序清单8-3 8-4 演示不同的exit值
 C和指针 3.9作用域、存储类型示例
 程序4-6 utime函数实例
 程序4-5 打开一个文件，然后unlink
C和指针笔记 3.8 static关键字
 C和指针笔记 3.7 存储类型
 C和指针笔记 3.6链接属性
 python爬虫<urlopen error [Errno 10061] >

原文地址：https://www.cnblogs.com/biechishaobing/p/10765174.html

Django学习笔记之数据库-模型的操作

模型的操作

添加模型

查找数据

查找所有数据

数据过滤

获取单个对象

数据排序

修改数据

删除数据

查询操作

查询条件

1.exact

2.iexact

3.contains

4.icontains

5.in

6.gt

7.gte

8.lt

9.lte

10.startswith

11.istartswith

12.endswith

13.iendswith：

14.range

15.date

16.year

17.month

18.day

19.week_day

20.time

21.isnull

22.regex和iregex

根据关联的表进行查询

聚合函数

聚合函数的基本方法

1.Avg

2.Count

3.Max和Min

4.Sum

aggregate和annotate的区别

F表达式和Q表达式

F表达式

Q表达式

ORM模型迁移

迁移命令

migrations中的迁移版本和数据库中的迁移版本对不上怎么办？

根据已有的表自动生成模型

1.`Avg`

2.`Count`

3.`Max`和`Min`

4.`Sum`