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.方法(参数视方法而定)

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

基于双下划线的模糊查询

1 Book.objects.filter(price__in=[100,200,300])
2 Book.objects.filter(price__gt=100)
3 Book.objects.filter(price__lt=100)
4 Book.objects.filter(price__range=[100,200])
5 Book.objects.filter(title__contains="python")
6 Book.objects.filter(title__icontains="python")
7 Book.objects.filter(title__startswith="py")
8 Book.objects.filter(pub_date__year=2012)

删除表记录

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

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

 1 删除方法就是 delete()。它运行时立即删除对象而不返回任何值。例如：
 2 
 3 
 4 model_obj.delete()
 5 你也可以一次性删除多个对象。每个 QuerySet 都有一个 delete() 方法，它一次性删除 QuerySet 中所有的对象。
 6 
 7 例如，下面的代码将删除 pub_date 是2005年的 Entry 对象：
 8 
 9 Entry.objects.filter(pub_date__year=2005).delete()
10 在 Django 删除对象时，会模仿 SQL 约束 ON DELETE CASCADE 的行为，换句话说，删除一个对象时也会删除与它相关联的外键对象。例如：
11 
12 
13 b = Blog.objects.get(pk=1)
14 # This will delete the Blog and all of its Entry objects.
15 b.delete()
16 要注意的是： delete() 方法是 QuerySet 上的方法，但并不适用于 Manager 本身。这是一种保护机制，是为了避免意外地调用 Entry.objects.delete() 方法导致 所有的 记录被误删除。如果你确认要删除所有的对象，那么你必须显式地调用：
17 
18 
19 Entry.objects.all().delete()　　
20 如果不想级联删除，可以设置为:
21 
22 
23 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进行设置

 1 DATABASES = {
 2     'default': {
 3         'ENGINE': 'django.db.backends.mysql',
 4         'NAME': 'lqz',
 5         'USER': 'root',
 6         'PASSWORD': '123456',
 7         'HOST': '127.0.0.1',
 8         'PORT': 3306,
 9         'ATOMIC_REQUEST': True,
10         'OPTIONS': {
11             "init_command": "SET storage_engine=MyISAM",
12         }
13     }
14 }
15 '''
16 'NAME':要连接的数据库，连接前需要创建好
17 'USER':连接数据库的用户名
18 'PASSWORD':连接数据库的密码
19 'HOST':连接主机，默认本机
20 'PORT':端口 默认3306
21 'ATOMIC_REQUEST': True,
22 设置为True统一个http请求对应的所有sql都放在一个事务中执行（要么所有都成功，要么所有都失败）。
23 是全局性的配置， 如果要对某个http请求放水（然后自定义事务），可以用non_atomic_requests修饰器 
24 'OPTIONS': {
25              "init_command": "SET storage_engine=MyISAM",
26             }
27 设置创建表的存储引擎为MyISAM，INNODB
28 '''

设置完后，再启动我们的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中进行如下配置：

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

增加，删除字段

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

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

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

注意：

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

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

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

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

在python中调用django环境

django.setup()是启动django

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

代码演示文件：settings views 和models

settings

  1 """
  2 Django settings for untitled2 project.
  3 
  4 Generated by 'django-admin startproject' using Django 1.11.
  5 
  6 For more information on this file, see
  7 https://docs.djangoproject.com/en/1.11/topics/settings/
  8 
  9 For the full list of settings and their values, see
 10 https://docs.djangoproject.com/en/1.11/ref/settings/
 11 """
 12 
 13 import os
 14 
 15 # Build paths inside the project like this: os.path.join(BASE_DIR, ...)
 16 BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 17 
 18 # Quick-start development settings - unsuitable for production
 19 # See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
 20 
 21 # SECURITY WARNING: keep the secret key used in production secret!
 22 SECRET_KEY = '^i6$8rw-6o+i%23ojoco1-9khepwdw!h=(+3j_$ubltrptho=!'
 23 
 24 # SECURITY WARNING: don't run with debug turned on in production!
 25 DEBUG = True
 26 
 27 ALLOWED_HOSTS = []
 28 
 29 # Application definition
 30 
 31 INSTALLED_APPS = [
 32     'django.contrib.admin',
 33     'django.contrib.auth',
 34     'django.contrib.contenttypes',
 35     'django.contrib.sessions',
 36     'django.contrib.messages',
 37     'django.contrib.staticfiles',
 38     'app01.apps.App01Config',
 39 ]
 40 
 41 MIDDLEWARE = [
 42     'django.middleware.security.SecurityMiddleware',
 43     'django.contrib.sessions.middleware.SessionMiddleware',
 44     'django.middleware.common.CommonMiddleware',
 45     # 'django.middleware.csrf.CsrfViewMiddleware',
 46     'django.contrib.auth.middleware.AuthenticationMiddleware',
 47     'django.contrib.messages.middleware.MessageMiddleware',
 48     'django.middleware.clickjacking.XFrameOptionsMiddleware',
 49 ]
 50 
 51 ROOT_URLCONF = 'untitled2.urls'
 52 # ROOT_URLCONF = 'app01.urls'
 53 
 54 TEMPLATES = [
 55     {
 56         'BACKEND': 'django.template.backends.django.DjangoTemplates',
 57         'DIRS': [os.path.join(BASE_DIR, 'templates')]
 58         ,
 59         'APP_DIRS': True,
 60         'OPTIONS': {
 61             'context_processors': [
 62                 'django.template.context_processors.debug',
 63                 'django.template.context_processors.request',
 64                 'django.contrib.auth.context_processors.auth',
 65                 'django.contrib.messages.context_processors.messages',
 66             ],
 67         },
 68     },
 69 ]
 70 
 71 WSGI_APPLICATION = 'untitled2.wsgi.application'
 72 
 73 # Database
 74 # https://docs.djangoproject.com/en/1.11/ref/settings/#databases
 75 
 76 DATABASES = {
 77     # 'default': {
 78     #     'ENGINE': 'django.db.backends.sqlite3',
 79     #     'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
 80     # }
 81     'default': {
 82         'ENGINE': 'django.db.backends.mysql',
 83         'NAME': 'dj1',
 84         'HOST': '127.0.0.1',
 85         'PORT': 3306,
 86         'USER': 'root',
 87         'PASSWORD': '123'
 88     }
 89 }
 90 
 91 # Password validation
 92 # https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators
 93 
 94 AUTH_PASSWORD_VALIDATORS = [
 95     {
 96         'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
 97     },
 98     {
 99         'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
100     },
101     {
102         'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
103     },
104     {
105         'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
106     },
107 ]
108 
109 # Internationalization
110 # https://docs.djangoproject.com/en/1.11/topics/i18n/
111 
112 LANGUAGE_CODE = 'en-us'
113 
114 TIME_ZONE = 'UTC'
115 
116 USE_I18N = True
117 
118 USE_L10N = True
119 
120 USE_TZ = True
121 
122 # Static files (CSS, JavaScript, Images)
123 # https://docs.djangoproject.com/en/1.11/howto/static-files/
124 
125 STATIC_URL = '/static/'
126 STATICFILES_DIRS = [
127     os.path.join(BASE_DIR, 'static')
128 ]
129 
130 LOGGING = {
131     'version': 1,
132     'disable_existing_loggers': False,
133     'handlers': {
134         'console':{
135             'level':'DEBUG',
136             'class':'logging.StreamHandler',
137         },
138     },
139     'loggers': {
140         'django.db.backends': {
141             'handlers': ['console'],
142             'propagate': True,
143             'level':'DEBUG',
144         },
145     }
146 }

settings

views

  1 import os
  2 if __name__ == '__main__':
  3     os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled2.settings")
  4     import django
  5     django.setup()
  6     from app01.models import *
  7 
  8     import datetime
  9 
 10     now = datetime.datetime.now()
 11     # *****增加*******
 12     # 第一种方式：(推荐用第一种）date类型需要注意：传字符串必须是：2014-09-18，也可以传datetime类型
 13     # book=Book.objects.create(name='红楼梦',price=12.1,pub_date='2014-09-18',publish_id = 1)
 14     # Book.objects.create(name='水浒传',price=17.1,pub_date=now,publish_id=2)
 15     # print(book,type(book))  # Book object   <class 'app01.models.Book'>
 16     # print(Book.objects,type(Book.objects)) # app01.Book.objects   <class 'django.db.models.manager.Manager'>
 17     # 第二种方式
 18     # book=Book(name='Pyhon开发',price=50,pub_date='2017-09-18',publish_id = 1)
 19     # book.save()
 20     # print(book)
 21     # *****查filter（--queryset对象）相当于sql的where 后面传的参数，都是and
 22     # books=Book.objects.filter(name='红楼梦',nid=3)
 23     # print(books)  # <QuerySet [<Book: Book object>]>
 24     # print(books.first().nid)  # books是一个queryset类型，通过first方法取出里面的对象，获得对象的nid值。
 25     # print(books[0].nid)
 26     # all() 拿所有的--queryset对象
 27     # books = Book.objects.all()  # 还是一个queryset类型 但是包含了所有的BOOK对象
 28     # print(books)
 29     # first() 从queryset里取出第一个值---->book对象
 30     # books = Book.objects.all().first()
 31     # print(books)
 32     # get只能用来查，返回一条数据的情况，数据多，数据少，都报错
 33     # book=Book.objects.get(name='Python开发')#会报错  因为会返回多条数据
 34     # print(book)
 35     # values 对应到sql相当于 select  这里的东西 from book---返回QuerySet对象
 36     # book=Book.objects.all().values('name','price').first()
 37     # book0=Book.objects.all().values('name','price')
 38     # book1=Book.objects.all().values().first() # 不指定字段默认所有字段
 39     # print(book0)
 40     # # 字典里有name和price的queryset类型对象集合。
 41     # print(book)
 42     # print(book1)
 43     # 一旦返回是queryset对象，可以继续点它的方法
 44     # book=Book.objects.all().values('name','price').filter(name='Pyhon开发').filter(id=4).values('id')
 45     # print(book)
 46     # exclude 除XX以外的
 47     # books=Book.objects.all().exclude(name='红楼梦').first().nid
 48     # print(books)
 49     # order_by 默认从小到大，想从大到小 (负号-)
 50     # books=Book.objects.all().order_by('price').first().nid
 51     # book1s=Book.objects.all().order_by('-price').first().nid
 52     # print(books,type(books))
 53     # print(book1s,type(book1s))
 54     # count  ---count后面不能继续点了
 55     # count=Book.objects.all().count()
 56     # print(count)
 57     # last()
 58     # Book.objects.all().last()
 59     # Book.objects.all()[-1]  #报错
 60     # exists 判断queryset里有没有数据，没有就是false，有就是true
 61     # ret=Book.objects.all().exists()
 62     # print(ret)
 63     # values_list 对比values：values_list：queryset里放元组， values：queryset里放字典
 64     # books=Book.objects.all().values_list('name','price')
 65     # print(books)
 66     # distinct
 67     # ret=Book.objects.values('publish').distinct()
 68     # print(ret)
 69     # 无意义
 70     # ret = Book.objects.all().distinct()
 71     # print(ret)
 72 
 73     # reverse 对查询结果反向排序
 74     # books = Book.objects.all().order_by('-price').reverse()
 75     # # 相当于
 76     # books = Book.objects.all().order_by('price')
 77     # books = Book.objects.all().order_by('-price', 'pub_date').reverse()
 78     # # 相当于
 79     # books = Book.objects.all().order_by('price', '-pub_date')
 80     # print(books)
 81 
 82     # ret=Book.objects.all().get(pk=1)
 83     # ret=Book.objects.get(pk=1)
 84     # ret=Book.objects.get(price=51)
 85     # ret=Book.objects.get(pk=100)
 86     # ret=Book.objects.filter()
 87     # ret=Book.objects.all().exclude(name='红楼梦')
 88     # ret 是queryset对象，query方法，
 89     # print(ret.query)  # query方法
 90     # print(ret)
 91     # from  django.db.models.manager import Manager
 92     # 默认升序
 93     # ret=Book.objects.all().order_by('price')
 94     # ret=Book.objects.all().order_by('-price','id')
 95     # ret=Book.objects.all().order_by('-price','id').reverse()
 96     # '''
 97     # 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
 98     # '''
 99     # 单纯用reverse没有效果
100     # ret=Book.objects.all().reverse().first().name
101     # ret1=Book.objects.all().first().name
102     # print(ret,ret1)
103     # ret1 = Book.objects.all().order_by('-price', 'nid').first().nid
104     # ret2 = Book.objects.all().order_by('-price', 'nid').reverse().first().nid
105     # # 相当于
106     # ret2 = Book.objects.all().order_by('price', '-id')
107     # print(ret1)
108     # print(ret2)
109     # ret=Book.objects.all().filter(price='51').count()
110     # print(ret)
111     # queryset对象来调用，返回布尔值
112     # ret=Book.objects.filter(pk=100).exists()
113     # print(ret)
114     # values  queryset对象来调用
115     # 这是错误的
116     # ret=Book.objects.all().first().values(*('name','price')) # 变量解压，随机打散
117     # print(ret)
118     # 拿到元祖
119     # ret=Book.objects.all().values_list('name','price').filter(name='水浒传')
120     # print(ret)
121     # distinct
122     # ret=Book.objects.all().values('price').distinct()
123     # print(ret)
124     # 基于双下划线的模糊查询　
125     # 以XX开头
126     # ret=Book.objects.all().filter(name__startswith='红')
127     # print(ret)
128     #以XX结尾
129     # ret=Book.objects.all().filter(name__endswith='传')
130     # print(ret)
131     #  包含XX  对应到sql# like %传%
132     # ret=Book.objects.all().filter(name__contains='传')
133     # print(ret)
134     # icontains 不区分大小写
135     # ret=Book.objects.filter(name="pyhon开2") # filter可以用于queryset和manager对象
136     # # ret=Book.objects.filter(name__icontains="pyhon")
137     # print(ret)
138 #     大于小于
139 #     ret=Book.objects.filter(price__gt='16')
140 #     ret=Book.objects.filter(price__lt='16')
141 #     ret=Book.objects.filter(price__lte='16')
142 #     ret=Book.objects.filter(price__gte='16')
143 #     ret1=Book.objects.filter(price__range=[1,100])
144 #     ret2 = Book.objects.filter(price__gte=1,price__lte=100)
145 #     print(ret1)
146 #     print(ret2)
147 #     查询id在后面列表里的数据
148 #     ret=Book.objects.filter(id__in=[1,2,3,100])
149 #     print(ret)
150 #     ret=Book.objects.filter(id__range=[1,4])
151 #     print(ret)
152 #     ret=Book.objects.filter(pub_date__year=2017)
153 #     ret=Book.objects.filter(pub_date__year__gt=2017)
154 #     ret=Book.objects.filter(pub_date__month__gt=3)
155 #     ret=Book.objects.filter(pub_date__day__in=[18,7])
156 #     ret=Book.objects.filter(pub_date__month=1)
157 #     print(ret)
158     # 删除
159     # queryset对象可以调用，对象可以调用
160     # ret=Book.objects.filter(name='水浒传').delete()
161     # ret=Book.objects.filter(name='红楼梦').first().delete()
162     # (1, {'app01.Book': 1})  1 影响一条记录   那个表的记录   1 影响这个表的记录
163     # print(ret)
164     # 这不可以 manager对象
165     # ret=Book.objects.delete()
166     # 这个可以
167     # ret=Book.objects.all().delete()
168     #  更新 返回结果是int类型，只能queryset对象来调，对象不能来调
169     # ret=Book.objects.all().filter(price=51)
170     # ret=Book.objects.all().filter(price=51).update(name='后楼梦')
171     # ret=Book.objects.all().filter(price=51).first()
172     # ret.update(name='水浒传')
173     # print(ret)

views

models

 1 from django.db import models
 2 
 3 # Create your models here.
 4 
 5 
 6 # class Book(models.Model):
 7 #     name=models.CharField(max_length=32)
 8 #     price=models.DecimalField(max_digits=5,decimal_places=2)
 9 #     pub_date=models.DateField()
10 #
11 #     author=models.CharField(max_length=32)
12 #     publish=models.CharField(max_length=64)
13 #
14 #     def __str__(self):
15 #         return self.name
16 
17 class Publish(models.Model):
18     nid=models.AutoField(primary_key=True)
19     name=models.CharField(max_length=32)
20     addr=models.CharField(max_length=64)
21     email=models.EmailField()
22 
23 class Author(models.Model):
24     nid=models.AutoField(primary_key=True)
25     name=models.CharField(max_length=32)
26     age=models.IntegerField()
27     # 一对一的关系，就要用onetoone，关联字段放在那都可以
28     # 不能用ForeignKey建立一对一的关系原因是：ForeignKey建立的外键不是唯一的，需要自己设置，不如onetoone直接
29     # 而且onetoone容易让别人一眼看出他们是什么关系。比如作者和他的详细信息，插入的时候如果用FOREIGNKEY，那么可以在
30     # 关联的字段插入相同的ID，但是一对一关系的表都是一一对应的，所以这就造成了容易出错且不会报错的情况。
31     # authordatil=models.ForeignKey(to='AuthorDetail',to_field='nid',unique=True)
32     authordatil=models.OneToOneField(to='AuthorDetail',to_field='nid')
33 
34 class AuthorDetail(models.Model):
35     nid=models.AutoField(primary_key=True)
36     phone=models.CharField(max_length=32)
37     email=models.EmailField()
38 
39 class Book(models.Model):
40     nid=models.AutoField(primary_key=True)
41     price=models.DecimalField(max_digits=5,decimal_places=2)
42     pub_date=models.DateField()
43     name=models.CharField(max_length=32,null=True)
44 
45     # 一旦确立的一对多的关系，关联字段一定要放在多的表
46     publish=models.ForeignKey(to='Publish',to_field='nid')
47     # 一旦确立多对多的关系，管理字段放在哪都可以
48     authors=models.ManyToManyField(to='Author')
49 #     django 它会创建第三张表，表里有三个字段  id   book_id   author_id  并且会做外键关联

models

相关阅读:
linux系统防火墙对访问服务器的影响
 Android 样式的开发（转）
Android开发学习总结(三)——appcompat_v7项目说明
 Android开发:碎片Fragment完全解析fragment_main.xml/activity_main.xml
BootStrap 常用控件总结
 mybatis自定义代码生成器（Generator）——自动生成model&dao代码
 MySql的下载和安装（解压版）
jquery mobile 表单提交图片/文件上传
 java读取.properties配置文件的几种方法
 AngularJS------认识AngularJS
原文地址：https://www.cnblogs.com/Roc-Atlantis/p/9567982.html