Django中对单表的增删改查

之前的简单预习，重点在后面

方式一：

# create方法的返回值book_obj就是插入book表中的python葵花宝典这本书籍纪录对象

  book_obj=Book.objects.create(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12")

 

方式二：

book_obj=Book(title="python葵花宝典",state=True,price=100,publish="苹果出版社",pub_date="2012-12-12")

book_obj.save()  # 对象.save()是必须有的

 

推荐用方式一

 

查询数据库常用的方法 ==》和查询请求体里面属性不同，注意区分, 查询请求体request.POST是一个queryset,这里用get方法查不到值默认返回None，而查询数据库get不到对象会直接报错。

  book_obj=Book.objects.方法(参数视方法而定)

 <> all():                  查询所有结果

 <> filter(**kwargs):       它包含了与所给筛选条件相匹配的对象

 <> get(**kwargs):          返回与所给筛选条件相匹配的对象，返回结果有且只有一个，
                             如果符合筛选条件的对象超过一个或者没有都会抛出错误。

 <> exclude(**kwargs):      它包含了与所给筛选条件不匹配的对象

 <> order_by(*field):       对查询结果排序

 <> reverse():              对查询结果反向排序

 <> count():                返回数据库中匹配查询(QuerySet)的对象数量。

 <> first():                返回第一条记录

 <> last():                返回最后一条记录

 <> exists():              如果QuerySet包含数据，就返回True，否则返回False

 <> values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列
                             model的实例化对象，而是一个可迭代的字典序列
 <> values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

 <> distinct():            从返回结果中剔除重复纪录

基于双下划线的模糊查询

 Book.objects.filter(price__in=[100,200,300])
 Book.objects.filter(price__gt=100)
 Book.objects.filter(price__lt=100)
 Book.objects.filter(price__range=[100,200])
 Book.objects.filter(title__contains="python")
 Book.objects.filter(title__icontains="python")
 Book.objects.filter(title__startswith="py")
 Book.objects.filter(pub_date__year=2012)

删除表记录

开始我们直接注释，然后makemigrations==》migrate直接刷入，下面直接调用封装的方法，更简便一点

注意一点：不能直接调用表名.objects进行删除！！！看下面

 删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：

 model_obj.delete()
 你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中所有的对象。

 例如，下面的代码将删除 pub_date 是2005年的 Entry 对象：

 Entry.objects.filter(pub_date__year=2005).delete()
 在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：

 b = Blog.objects.get(pk=1)
 # This will delete the Blog and all of its Entry objects.
 b.delete()
 要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：

 Entry.objects.all().delete()　　
 如果不想级联删除，可以设置为:

 pubHouse = models.ForeignKey(to='Publisher', on_delete=models.SET_NULL, blank=True, null=True)

修改表记录

Book.objects.filter(title__startswith="py").update(price=120)

此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。　　

加上笔记的Django中单表的详细操作

将models里面创建的表存储到mysql数据库中，应当在settings进行设置

 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': 'lqz',
         'USER': 'root',
         'PASSWORD': '',
         'HOST': '127.0.0.1',
         'PORT': 3306,
         'ATOMIC_REQUEST': True,
         'OPTIONS': {
             "init_command": "SET storage_engine=MyISAM",
         }
     }
 }
 '''
 'NAME':要连接的数据库，连接前需要创建好
 'USER':连接数据库的用户名
 'PASSWORD':连接数据库的密码
 'HOST':连接主机，默认本机
 'PORT':端口 默认3306
 'ATOMIC_REQUEST': True,
 设置为True统一个http请求对应的所有sql都放在一个事务中执行（要么所有都成功，要么所有都失败）。
 是全局性的配置， 如果要对某个http请求放水（然后自定义事务），可以用non_atomic_requests修饰器
 'OPTIONS': {
              "init_command": "SET storage_engine=MyISAM",
             }
 设置创建表的存储引擎为MyISAM，INNODB
 '''

设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。然后，启动项目，会报错：no module named MySQLdb 。这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb 对于py3有很大问题，所以我们需要的驱动是PyMySQL 所以，我们只需要找到项目名文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()

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

python manage.py makemigrations
python manage.py migrate

确保配置文件中的INSTALLED_APPS中写入我们创建的app名称,要确保添加在installed_apps.

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

 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'handlers': {
         'console':{
             'level':'DEBUG',
             'class':'logging.StreamHandler',
         },
     },
     'loggers': {
         'django.db.backends': {
             'handlers': ['console'],
             'propagate': True,
             'level':'DEBUG',
         },
     }
 }

增加，删除字段

　　删除，直接注释掉字段，执行数据库迁移命令即可，如果想直接删除整个表，直接把整个表注释掉，再执行数据库迁移命令。

　　新增字段，在类里直接新增字段，直接执行数据库迁移命令会提示输入默认值，此时需要设置之前已经创建记录的默认值，如下：

publish = models.CharField(max_length=12,default='人民出版社',null=True)

注意：

　　1 数据库迁移记录都在 app01下的migrations里

　　2 使用showmigrations命令可以查看没有执行migrate的文件

　　3  makemigrations是生成一个文件，migrate是将更改提交到数据量

如果需要在Django环境中的文件里右击直接执行对表的增删改查，需要在文件里加上一段代码

在python中调用django环境

django.setup()是启动django

 import os
 if __name__ == '__main__':
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled2.settings")
     import django
     django.setup()
     from app01.models import *

代码演示文件：settings  views 和models

settings

 """
 Django settings for untitled2 project.

 Generated by 'django-admin startproject' using Django 1.11.

 For more information on this file, see
 https://docs.djangoproject.com/en/1.11/topics/settings/

 For the full list of settings and their values, see
 https://docs.djangoproject.com/en/1.11/ref/settings/
 """

 import os

 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

 # Quick-start development settings - unsuitable for production
 # See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/

 # SECURITY WARNING: keep the secret key used in production secret!
 SECRET_KEY = '^i6$8rw-6o+i%23ojoco1-9khepwdw!h=(+3j_$ubltrptho=!'

 # SECURITY WARNING: don't run with debug turned on in production!
 DEBUG = True

 ALLOWED_HOSTS = []

 # Application definition

 INSTALLED_APPS = [
     'django.contrib.admin',
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     'django.contrib.messages',
     'django.contrib.staticfiles',
     'app01.apps.App01Config',
 ]

 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',
 ]

 ROOT_URLCONF = 'untitled2.urls'
 # ROOT_URLCONF = 'app01.urls'

 TEMPLATES = [
     {
         'BACKEND': 'django.template.backends.django.DjangoTemplates',
         'DIRS': [os.path.join(BASE_DIR, 'templates')]
         ,
         'APP_DIRS': True,
         'OPTIONS': {
             'context_processors': [
                 'django.template.context_processors.debug',
                 'django.template.context_processors.request',
                 'django.contrib.auth.context_processors.auth',
                 'django.contrib.messages.context_processors.messages',
             ],
         },
     },
 ]

 WSGI_APPLICATION = 'untitled2.wsgi.application'

 # Database
 # https://docs.djangoproject.com/en/1.11/ref/settings/#databases

 DATABASES = {
     # 'default': {
     #     'ENGINE': 'django.db.backends.sqlite3',
     #     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
     # }
     'default': {
         'ENGINE': 'django.db.backends.mysql',
         'NAME': 'dj1',
         'HOST': '127.0.0.1',
         'PORT': 3306,
         'USER': 'root',
         'PASSWORD': ''
     }
 }

 # Password validation
 # https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators

 AUTH_PASSWORD_VALIDATORS = [
     {
         'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
     },
     {
         'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
     },
     {
         'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
     },
     {
         'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
     },
 ]

 # Internationalization
 # https://docs.djangoproject.com/en/1.11/topics/i18n/

 LANGUAGE_CODE = 'en-us'

 TIME_ZONE = 'UTC'

 USE_I18N = True

 USE_L10N = True

 USE_TZ = True

 # Static files (CSS, JavaScript, Images)
 # https://docs.djangoproject.com/en/1.11/howto/static-files/

 STATIC_URL = '/static/'
 STATICFILES_DIRS = [
     os.path.join(BASE_DIR, 'static')
 ]

 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'handlers': {
         'console':{
             'level':'DEBUG',
             'class':'logging.StreamHandler',
         },
     },
     'loggers': {
         'django.db.backends': {
             'handlers': ['console'],
             'propagate': True,
             'level':'DEBUG',
         },
     }
 }

settings

views

 import os
 if __name__ == '__main__':
     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled2.settings")
     import django
     django.setup()
     from app01.models import *

     import datetime

     now = datetime.datetime.now()
     # *****增加*******
     # 第一种方式：(推荐用第一种）date类型需要注意：传字符串必须是：2014-09-18，也可以传datetime类型
     # book=Book.objects.create(name='红楼梦',price=12.1,pub_date='2014-09-18',publish_id = 1)
     # Book.objects.create(name='水浒传',price=17.1,pub_date=now,publish_id=2)
     # print(book,type(book))  # Book object   <class 'app01.models.Book'>
     # print(Book.objects,type(Book.objects)) # app01.Book.objects   <class 'django.db.models.manager.Manager'>
     # 第二种方式
     # book=Book(name='Pyhon开发',price=50,pub_date='2017-09-18',publish_id = 1)
     # book.save()
     # print(book)
     # *****查filter（--queryset对象）相当于sql的where 后面传的参数，都是and
     # books=Book.objects.filter(name='红楼梦',nid=3)
     # print(books)  # <QuerySet [<Book: Book object>]>
     # print(books.first().nid)  # books是一个queryset类型，通过first方法取出里面的对象，获得对象的nid值。
     # print(books[0].nid)
     # all() 拿所有的--queryset对象
     # books = Book.objects.all()  # 还是一个queryset类型 但是包含了所有的BOOK对象
     # print(books)
     # first() 从queryset里取出第一个值---->book对象
     # books = Book.objects.all().first()
     # print(books)
     # get只能用来查，返回一条数据的情况，数据多，数据少，都报错
     # book=Book.objects.get(name='Python开发')#会报错  因为会返回多条数据
     # print(book)
     # values 对应到sql相当于 select  这里的东西 from book---返回QuerySet对象
     # book=Book.objects.all().values('name','price').first()
     # book0=Book.objects.all().values('name','price')
     # book1=Book.objects.all().values().first() # 不指定字段默认所有字段
     # print(book0)
     # # 字典里有name和price的queryset类型对象集合。
     # print(book)
     # print(book1)
     # 一旦返回是queryset对象，可以继续点它的方法
     # book=Book.objects.all().values('name','price').filter(name='Pyhon开发').filter(id=4).values('id')
     # print(book)
     # exclude 除XX以外的
     # books=Book.objects.all().exclude(name='红楼梦').first().nid
     # print(books)
     # order_by 默认从小到大，想从大到小 (负号-)
     # books=Book.objects.all().order_by('price').first().nid
     # book1s=Book.objects.all().order_by('-price').first().nid
     # print(books,type(books))
     # print(book1s,type(book1s))
     # count  ---count后面不能继续点了
     # count=Book.objects.all().count()
     # print(count)
     # last()
     # Book.objects.all().last()
     # Book.objects.all()[-1]  #报错
     # exists 判断queryset里有没有数据，没有就是false，有就是true
     # ret=Book.objects.all().exists()
     # print(ret)
     # values_list 对比values：values_list：queryset里放元组， values：queryset里放字典
     # books=Book.objects.all().values_list('name','price')
     # print(books)
     # distinct
     # ret=Book.objects.values('publish').distinct()
     # print(ret)
     # 无意义
     # ret = Book.objects.all().distinct()
     # print(ret)

     # reverse 对查询结果反向排序
     # books = Book.objects.all().order_by('-price').reverse()
     # # 相当于
     # books = Book.objects.all().order_by('price')
     # books = Book.objects.all().order_by('-price', 'pub_date').reverse()
     # # 相当于
     # books = Book.objects.all().order_by('price', '-pub_date')
     # print(books)

     # ret=Book.objects.all().get(pk=1)
     # ret=Book.objects.get(pk=1)
     # ret=Book.objects.get(price=51)
     # ret=Book.objects.get(pk=100)
     # ret=Book.objects.filter()
     # ret=Book.objects.all().exclude(name='红楼梦')
     # ret 是queryset对象，query方法，
     # print(ret.query)  # query方法
     # print(ret)
     # from  django.db.models.manager import Manager
     # 默认升序
     # ret=Book.objects.all().order_by('price')
     # ret=Book.objects.all().order_by('-price','id')
     # ret=Book.objects.all().order_by('-price','id').reverse()
     # '''
     # SELECT `app01_book`.`id`, `app01_book`.`name`, `app01_book`.`price`, `app01_book`.`pub_date`, `app01_book`.`author`, `app01_book`.`publish` FROM `app01_book` ORDER BY `app01_book`.`price` DESC, `app01_book`.`id` ASC
     # '''
     # 单纯用reverse没有效果
     # ret=Book.objects.all().reverse().first().name
     # ret1=Book.objects.all().first().name
     # print(ret,ret1)
     # ret1 = Book.objects.all().order_by('-price', 'nid').first().nid
     # ret2 = Book.objects.all().order_by('-price', 'nid').reverse().first().nid
     # # 相当于
     # ret2 = Book.objects.all().order_by('price', '-id')
     # print(ret1)
     # print(ret2)
     # ret=Book.objects.all().filter(price='51').count()
     # print(ret)
     # queryset对象来调用，返回布尔值
     # ret=Book.objects.filter(pk=100).exists()
     # print(ret)
     # values  queryset对象来调用
     # 这是错误的
     # ret=Book.objects.all().first().values(*('name','price')) # 变量解压，随机打散
     # print(ret)
     # 拿到元祖
     # ret=Book.objects.all().values_list('name','price').filter(name='水浒传')
     # print(ret)
     # distinct
     # ret=Book.objects.all().values('price').distinct()
     # print(ret)
     # 基于双下划线的模糊查询　
     # 以XX开头
     # ret=Book.objects.all().filter(name__startswith='红')
     # print(ret)
     #以XX结尾
     # ret=Book.objects.all().filter(name__endswith='传')
     # print(ret)
     #  包含XX  对应到sql# like %传%
     # ret=Book.objects.all().filter(name__contains='传')
     # print(ret)
     # icontains 不区分大小写
     # ret=Book.objects.filter(name="pyhon开2") # filter可以用于queryset和manager对象
     # # ret=Book.objects.filter(name__icontains="pyhon")
     # print(ret)
 #     大于小于
 #     ret=Book.objects.filter(price__gt='16')
 #     ret=Book.objects.filter(price__lt='16')
 #     ret=Book.objects.filter(price__lte='16')
 #     ret=Book.objects.filter(price__gte='16')
 #     ret1=Book.objects.filter(price__range=[1,100])
 #     ret2 = Book.objects.filter(price__gte=1,price__lte=100)
 #     print(ret1)
 #     print(ret2)
 #     查询id在后面列表里的数据
 #     ret=Book.objects.filter(id__in=[1,2,3,100])
 #     print(ret)
 #     ret=Book.objects.filter(id__range=[1,4])
 #     print(ret)
 #     ret=Book.objects.filter(pub_date__year=2017)
 #     ret=Book.objects.filter(pub_date__year__gt=2017)
 #     ret=Book.objects.filter(pub_date__month__gt=3)
 #     ret=Book.objects.filter(pub_date__day__in=[18,7])
 #     ret=Book.objects.filter(pub_date__month=1)
 #     print(ret)
     # 删除
     # queryset对象可以调用，对象可以调用
     # ret=Book.objects.filter(name='水浒传').delete()
     # ret=Book.objects.filter(name='红楼梦').first().delete()
     # (1, {'app01.Book': 1})  1 影响一条记录   那个表的记录   1 影响这个表的记录
     # print(ret)
     # 这不可以 manager对象
     # ret=Book.objects.delete()
     # 这个可以
     # ret=Book.objects.all().delete()
     #  更新 返回结果是int类型，只能queryset对象来调，对象不能来调
     # ret=Book.objects.all().filter(price=51)
     # ret=Book.objects.all().filter(price=51).update(name='后楼梦')
     # ret=Book.objects.all().filter(price=51).first()
     # ret.update(name='水浒传')
     # print(ret)

views

models

 from django.db import models

 # Create your models here.

 # class Book(models.Model):
 #     name=models.CharField(max_length=32)
 #     price=models.DecimalField(max_digits=5,decimal_places=2)
 #     pub_date=models.DateField()
 #
 #     author=models.CharField(max_length=32)
 #     publish=models.CharField(max_length=64)
 #
 #     def __str__(self):
 #         return self.name

 class Publish(models.Model):
     nid=models.AutoField(primary_key=True)
     name=models.CharField(max_length=32)
     addr=models.CharField(max_length=64)
     email=models.EmailField()

 class Author(models.Model):
     nid=models.AutoField(primary_key=True)
     name=models.CharField(max_length=32)
     age=models.IntegerField()
     # 一对一的关系，就要用onetoone，关联字段放在那都可以
     # 不能用ForeignKey建立一对一的关系原因是：ForeignKey建立的外键不是唯一的，需要自己设置，不如onetoone直接
     # 而且onetoone容易让别人一眼看出他们是什么关系。比如作者和他的详细信息，插入的时候如果用FOREIGNKEY，那么可以在
     # 关联的字段插入相同的ID，但是一对一关系的表都是一一对应的，所以这就造成了容易出错且不会报错的情况。
     # authordatil=models.ForeignKey(to='AuthorDetail',to_field='nid',unique=True)
     authordatil=models.OneToOneField(to='AuthorDetail',to_field='nid')

 class AuthorDetail(models.Model):
     nid=models.AutoField(primary_key=True)
     phone=models.CharField(max_length=32)
     email=models.EmailField()

 class Book(models.Model):
     nid=models.AutoField(primary_key=True)
     price=models.DecimalField(max_digits=5,decimal_places=2)
     pub_date=models.DateField()
     name=models.CharField(max_length=32,null=True)

     # 一旦确立的一对多的关系，关联字段一定要放在多的表
     publish=models.ForeignKey(to='Publish',to_field='nid')
     # 一旦确立多对多的关系，管理字段放在哪都可以
     authors=models.ManyToManyField(to='Author')
 #     django 它会创建第三张表，表里有三个字段  id   book_id   author_id  并且会做外键关联

models