django2

八 Models

数据库的配置

1    django默认支持sqlite，mysql, oracle,postgresql数据库。

     <1> sqlite

            django默认使用sqlite的数据库，默认自带sqlite的数据库驱动 , 引擎名称：django.db.backends.sqlite3

     <2> mysql

            引擎名称：django.db.backends.mysql

2    mysql驱动程序

•    MySQLdb(mysql python)
•    mysqlclient
•    MySQL
•    PyMySQL(纯python的mysql驱动程序)

3     在django的项目中会默认使用sqlite数据库，在settings里有如下设置：

如果我们想要更改数据库，需要修改如下：

 

DATABASES = {

    'default': {

        'ENGINE': 'django.db.backends.mysql', 

        'NAME': 'books',    #你的数据库名称

        'USER': 'root',   #你的数据库用户名

        'PASSWORD': '', #你的数据库密码

        'HOST': '', #你的数据库主机，留空默认为localhost

        'PORT': '3306', #你的数据库端口

    }

}

View Code

注意：

NAME即数据库的名字，在mysql连接前该数据库必须已经创建，而上面的sqlite数据库下的db.sqlite3则是项目自动创建

USER和PASSWORD分别是数据库的用户名和密码。

设置完后，再启动我们的Django项目前，我们需要激活我们的mysql。

然后，启动项目，会报错：no module named MySQLdb

这是因为django默认你导入的驱动是MySQLdb，可是MySQLdb对于py3有很大问题，所以我们需要的驱动是PyMySQL

所以，我们只需要找到项目名文件下的__init__,在里面写入：

import pymysql
pymysql.install_as_MySQLdb()

问题解决！

View Code

ORM(对象关系映射)

用于实现面向对象编程语言里不同类型系统的数据之间的转换，换言之，就是用面向对象的方式去操作数据库的创建表以及增删改查等操作。

优点： 1 ORM使得我们的通用数据库交互变得简单易行，而且完全不用考虑该死的SQL语句。快速开发，由此而来。

          2 可以避免一些新手程序猿写sql语句带来的性能问题。

            比如 我们查询User表中的所有字段:

            新手可能会用select ＊ from  auth_user,这样会因为多了一个匹配动作而影响效率的。

 缺点：1  性能有所牺牲，不过现在的各种ORM框架都在尝试各种方法，比如缓存，延迟加载登来减轻这个问题。效果很显著。

          2  对于个别复杂查询，ORM仍然力不从心，为了解决这个问题，ORM一般也支持写raw sql。

          3  通过QuerySet的query属性查询对应操作的sql语句

author_obj=models.Author.objects.filter(id=2)
print(author_obj.query)

     下面要开始学习Django ORM语法了，为了更好的理解，我们来做一个基本的 书籍/作者/出版商 数据库结构。 我们这样做是因为 这是一个众所周知的例子，很多SQL有关的书籍也常用这个举例。

表(模型)的创建：

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

作者模型：一个作者有姓名。

作者详细模型：把作者的详情放到详情表，包含性别，email地址和出生日期，作者详情模型和作者模型之间是一对一的关系（one－to－one）（类似于每个人和他的身份证之间的关系），在大多数情况下我们没有必要将他们拆分成两张表，这里只是引出一对一的概念。

出版商模型：出版商有名称，地址，所在城市，省，国家和网站。

书籍模型：书籍有书名和出版日期，一本书可能会有多个作者，一个作者也可以写多本书，所以作者和书籍的关系就是多对多的关联关系（many－to－many），一本书只应该由一个出版商出版，所以出版商和书籍是一对多关联关系（one－to－many），也被称作外键。

from django.db import models<br>
class Publisher(models.Model):
    name = models.CharField(max_length=30, verbose_name="名称")
    address = models.CharField("地址", max_length=50)
    city = models.CharField('城市',max_length=60)
    state_province = models.CharField(max_length=30)
    country = models.CharField(max_length=50)
    website = models.URLField()
 
    class Meta:
        verbose_name = '出版商'
        verbose_name_plural = verbose_name
 
    def __str__(self):
        return self.name
 
class Author(models.Model):
    name = models.CharField(max_length=30)
    def __str__(self):
        return self.name
 
class AuthorDetail(models.Model):
    sex = models.BooleanField(max_length=1, choices=((0, '男'),(1, '女'),))
    email = models.EmailField()
    address = models.CharField(max_length=50)
    birthday = models.DateField()
    author = models.OneToOneField(Author)
 
class Book(models.Model):
    title = models.CharField(max_length=100)
    authors = models.ManyToManyField(Author)
    publisher = models.ForeignKey(Publisher)
    publication_date = models.DateField()
    price=models.DecimalField(max_digits=5,decimal_places=2,default=10)
    def __str__(self):
        return self.title

View Code

注意1：记得在settings里的INSTALLED_APPS中加入'app01',然后再同步数据库。

注意2: models.ForeignKey("Publish") & models.ForeignKey(Publish)

分析代码：

       <1>  每个数据模型都是django.db.models.Model的子类，它的父类Model包含了所有必要的和数据库交互的方法。并提供了一个简介漂亮的定义数据库字段的语法。

       <2>  每个模型相当于单个数据库表（多对多关系例外，会多生成一张关系表），每个属性也是这个表中的字段。属性名就是字段名，它的类型（例如CharField）相当于数据库的字段类型（例如varchar）。大家可以留意下其它的类型都和数据库里的什么字段对应。

       <3>  模型之间的三种关系：一对一，一对多，多对多。

             一对一：实质就是在主外键（author_id就是foreign key）的关系基础上，给外键加了一个UNIQUE＝True的属性；

             一对多：就是主外键关系；（foreign key）

             多对多：(ManyToManyField) 自动创建第三张表(当然我们也可以自己创建第三张表：两个foreign key)

       <4>  模型常用的字段类型参数

<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 用一个部件表示该字段保存的数据(一个文件上传部件) .

     #注意：在一个 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 用一个  文本框表示该字段保存的数据(一个单行编辑框)

<13> NullBooleanField
       # 类似 BooleanField, 不过允许 NULL 作为其中一个选项. 推荐使用这个字段而不要用 BooleanField 加 null=True 选项
       # admin 用一个选择框  (三个可选择的值: "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参数. 
     
    View Code 
    
   
<5>  Field重要参数
 
   
 
     
     
    
 
     
<1> null ： 数据库中字段是否可以为空

    <2> blank： django的 Admin 中添加数据时是否可允许空值

    <3> default：设定缺省值

    <4> editable：如果为假，admin模式下将不能改写。缺省为真

    <5> primary_key：设置主键，如果没有设置django创建表时会自动加上：
        id = meta.AutoField('ID', primary_key=True)
        primary_key=True implies blank=False, null=False and unique=True. Only one
        primary key is allowed on an object.

    <6> unique：数据唯一

    <7> verbose_name　　Admin中字段的显示名称

    <8> validator_list：有效性检查。非有效产生 django.core.validators.ValidationError 错误


    <9> db_column，db_index 如果为真将为此字段创建索引

    <10>choices：一个用来选择值的2维元组。第一个值是实际存储的值，第二个用来方便进行选择。
                如SEX_CHOICES= (( ‘F’,'Female’),(‘M’,'Male’),)
                gender = models.CharField(max_length=2,choices = SEX_CHOICES)
 
    
 
    View Code 
   
 
   
表的操作(增删改查)：
 
   
-------------------------------------增(create  ,  save) -------------------------------
 
   
 
    
from app01.models import *

    #create方式一:   Author.objects.create(name='Alvin')

    #create方式二:   Author.objects.create(**{"name":"alex"})

    #save方式一:     author=Author(name="alvin")
                    author.save()

    #save方式二:     author=Author()
                    author.name="alvin"
                    author.save()
 
   
 
   
重点来了－－－－－－－>那么如何创建存在一对多或多对多关系的一本书的信息呢？(如何处理外键关系的字段如一对多的publisher和多对多的authors)
 
   
 
     
     
    
 
     
#一对多(ForeignKey):

    #方式一: 由于绑定一对多的字段,比如publish,存到数据库中的字段名叫publish_id,所以我们可以直接给这个
    #       字段设定对应值:
           Book.objects.create(title='php',
                               publisher_id=2,   #这里的2是指为该book对象绑定了Publisher表中id=2的行对象
                               publication_date='2017-7-7',
                               price=99)


    #方式二:
    #       <1> 先获取要绑定的Publisher对象:
        pub_obj=Publisher(name='河大出版社',address='保定',city='保定',
                state_province='河北',country='China',website='http://www.hbu.com')
    OR  pub_obj=Publisher.objects.get(id=1)

    #       <2>将 publisher_id=2 改为  publisher=pub_obj

#多对多(ManyToManyField()):

    author1=Author.objects.get(id=1)
    author2=Author.objects.filter(name='alvin')[0]
    book=Book.objects.get(id=1)
    book.authors.add(author1,author2)
    #等同于:
    book.authors.add(*[author1,author2])
    book.authors.remove(*[author1,author2])
    #-------------------
    book=models.Book.objects.filter(id__gt=1)
    authors=models.Author.objects.filter(id=1)[0]
    authors.book_set.add(*book)
    authors.book_set.remove(*book)
    #-------------------
    book.authors.add(1)
    book.authors.remove(1)
    authors.book_set.add(1)
    authors.book_set.remove(1)

#注意: 如果第三张表是通过models.ManyToManyField()自动创建的,那么绑定关系只有上面一种方式
#     如果第三张表是自己创建的:
     class Book2Author(models.Model):
            author=models.ForeignKey("Author")
            Book=  models.ForeignKey("Book")
#     那么就还有一种方式:
            author_obj=models.Author.objects.filter(id=2)[0]
            book_obj  =models.Book.objects.filter(id=3)[0]

            s=models.Book2Author.objects.create(author_id=1,Book_id=2)
            s.save()
            s=models.Book2Author(author=author_obj,Book_id=1)
            s.save()
 
    
 
    View Code 
   
 
   
-----------------------------------------删（delete） ---------------------------------------------
 
   
 
    
>>> Book.objects.filter(id=1).delete()
(3, {'app01.Book_authors': 2, 'app01.Book': 1})
 
   
 
   
我们表面上删除了一条信息，实际却删除了三条，因为我们删除的这本书在Book_authors表中有两条相关信息，这种删除方式就是django默认的级联删除。
 
   
如果是多对多的关系： remove()和clear()方法：
 
   
 
    
#正向
book = models.Book.objects.filter(id=1)

#删除第三张表中和女孩1关联的所有关联信息
book.author.clear()        #清空与book中id=1 关联的所有数据
book.author.remove(2)  #可以为id
book.author.remove(*[1,2,3,4])     #可以为列表,前面加*

#反向
author = models.Author.objects.filter(id=1)
author.book_set.clear() #清空与boy中id=1 关联的所有数据
 
   
 
   
----------------------------------------改（update和save） ----------------------------------------
 
   
实例：
 
   
 
   
注意：
 
   
<1> 第二种方式修改不能用get的原因是：update是QuerySet对象的方法，get返回的是一个model对象，它没有update方法，而filter返回的是一个QuerySet对象(filter里面的条件可能有多个条件符合，比如name＝'alvin',可能有两个name＝'alvin'的行数据)。
 
   
<2>在“插入和更新数据”小节中，我们有提到模型的save()方法，这个方法会更新一行里的所有列。 而某些情况下，我们只需要更新行里的某几列。
 
   
 
     
     
    
 
     
#---------------- update方法直接设定对应属性----------------
    models.Book.objects.filter(id=3).update(title="PHP")
    ##sql:
    ##UPDATE "app01_book" SET "title" = 'PHP' WHERE "app01_book"."id" = 3; args=('PHP', 3)


#--------------- save方法会将所有属性重新设定一遍,效率低-----------
    obj=models.Book.objects.filter(id=3)[0]
    obj.title="Python"
    obj.save()
# SELECT "app01_book"."id", "app01_book"."title", "app01_book"."price", 
# "app01_book"."color", "app01_book"."page_num", 
# "app01_book"."publisher_id" FROM "app01_book" WHERE "app01_book"."id" = 3 LIMIT 1; 
# 
# UPDATE "app01_book" SET "title" = 'Python', "price" = 3333, "color" = 'red', "page_num" = 556,
# "publisher_id" = 1 WHERE "app01_book"."id" = 3;
 
    
 
    View Code 
   
 
   
      在这个例子里我们可以看到Django的save()方法更新了不仅仅是title列的值，还有更新了所有的列。 若title以外的列有可能会被其他的进程所改动的情况下，只更改title列显然是更加明智的。更改某一指定的列，我们可以调用结果集（QuerySet）对象的update()方法,与之等同的SQL语句变得更高效，并且不会引起竞态条件。
 
   
此外，update()方法对于任何结果集（QuerySet）均有效，这意味着你可以同时更新多条记录update()方法会返回一个整型数值，表示受影响的记录条数。
 
   
注意，这里因为update返回的是一个整形，所以没法用query属性；对于每次创建一个对象，想显示对应的raw 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',
        },
    }
}

LOGGING
 
    
 
    输出LOGGING 
   
 
   
注意：如果是多对多的改：
 
   
 
    
 obj=Book.objects.filter(id=1)[0]
    author=Author.objects.filter(id__gt=2)

    obj.author.clear()
    obj.author.add(*author)
 
   
 
   
---------------------------------------查（filter，value等) -------------------------------------
 
   
---------->查询API：
 
   
 
     
     
    
 
     
# 查询相关API：

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

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

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

#-----------下面的方法都是对查询的结果再进行处理:比如 objects.filter.values()--------

#  <4>values(*field):        返回一个ValueQuerySet——一个特殊的QuerySet，运行后得到的并不是一系列 model的实例化对象，而是一个可迭代的字典序列
                                     
#  <5>exclude(**kwargs):     它包含了与所给筛选条件不匹配的对象

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

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

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

#  <9>values_list(*field):   它与values()非常相似，它返回的是一个元组序列，values返回的是一个字典序列

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

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

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

#  <13>exists():             如果QuerySet包含数据，就返回True，否则返回False。
 
    
 
    View Code 
   
 
   
补充：
 
   
 
     
     
    
 
     
#扩展查询,有时候DJANGO的查询API不能方便的设置查询条件，提供了另外的扩展查询方法extra:
#extra(select=None, where=None, params=None, tables=None,order_by=None, select_params=None

(1)  Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
(2)  Blog.objects.extra(
        select=SortedDict([('a', '%s'), ('b', '%s')]),
        select_params=('one', 'two'))

(3)  q = Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})
     q = q.extra(order_by = ['-is_recent'])

(4)  Entry.objects.extra(where=['headline=%s'], params=['Lennon'])  

extra
 
    
 
    View Code 
   
 
   
---------->惰性机制：
 
   
所谓惰性机制：Publisher.objects.all()或者.filter()等都只是返回了一个QuerySet（查询结果集对象），它并不会马上执行sql，而是当调用QuerySet的时候才执行。
 
   
QuerySet特点：
 
   
       <1>  可迭代的
 
   
       <2>  可切片
 
   
 
     
     
    
 
     
#objs=models.Book.objects.all()#[obj1,obj2,ob3...]

    #QuerySet:   可迭代

    # for obj in objs:#每一obj就是一个行对象
    #     print("obj:",obj)
    # QuerySet:  可切片

    # print(objs[1])
    # print(objs[1:4])
    # print(objs[::-1])
 
    
 
    View Code 
   
 
   
QuerySet的高效使用：
 
   
 
     
     
    
 
     
<1>Django的queryset是惰性的

     Django的queryset对应于数据库的若干记录（row），通过可选的查询来过滤。例如，下面的代码会得
     到数据库中名字为‘Dave’的所有的人:person_set = Person.objects.filter(first_name="Dave")
     上面的代码并没有运行任何的数据库查询。你可以使用person_set，给它加上一些过滤条件，或者将它传给某个函数，
     这些操作都不会发送给数据库。这是对的，因为数据库查询是显著影响web应用性能的因素之一。

<2>要真正从数据库获得数据，你可以遍历queryset或者使用if queryset,总之你用到数据时就会执行sql.
   为了验证这些,需要在settings里加入 LOGGING(验证方式)
        obj=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)

        # if obj:
        #     print("ok")

<3>queryset是具有cache的
     当你遍历queryset时，所有匹配的记录会从数据库获取，然后转换成Django的model。这被称为执行
    （evaluation）.这些model会保存在queryset内置的cache中，这样如果你再次遍历这个queryset，
     你不需要重复运行通用的查询。
        obj=models.Book.objects.filter(id=3)

        # for i in obj:
        #     print(i)
                          ## models.Book.objects.filter(id=3).update(title="GO")
                          ## obj_new=models.Book.objects.filter(id=3)
        # for i in obj:
        #     print(i)   #LOGGING只会打印一次

<4>
     简单的使用if语句进行判断也会完全执行整个queryset并且把数据放入cache，虽然你并不需要这些
     数据！为了避免这个，可以用exists()方法来检查是否有数据：

            obj = Book.objects.filter(id=4)
            #  exists()的检查可以避免数据放入queryset的cache。
            if obj.exists():
                print("hello world!")

<5>当queryset非常巨大时，cache会成为问题

     处理成千上万的记录时，将它们一次装入内存是很浪费的。更糟糕的是，巨大的queryset可能会锁住系统
     进程，让你的程序濒临崩溃。要避免在遍历数据的同时产生queryset cache，可以使用iterator()方法
     来获取数据，处理完数据就将其丢弃。
        objs = Book.objects.all().iterator()
        # iterator()可以一次只从数据库获取少量数据，这样可以节省内存
        for obj in objs:
            print(obj.name)
        #BUT,再次遍历没有打印,因为迭代器已经在上一次遍历(next)到最后一次了,没得遍历了
        for obj in objs:
            print(obj.name)

     #当然，使用iterator()方法来防止生成cache，意味着遍历同一个queryset时会重复执行查询。所以使
     #用iterator()的时候要当心，确保你的代码在操作一个大的queryset时没有重复执行查询

总结:
    queryset的cache是用于减少程序对数据库的查询，在通常的使用下会保证只有在需要的时候才会查询数据库。
使用exists()和iterator()方法可以优化程序对内存的使用。不过，由于它们并不会生成queryset cache，可能
会造成额外的数据库查询。
 
    
 
    View Code 
   
 
   
---------->对象查询，单表条件查询，多表条件关联查询
 
   
 
     
     
    
 
     
#--------------------对象形式的查找--------------------------
    # 正向查找
    ret1=models.Book.objects.first()
    print(ret1.title)
    print(ret1.price)
    print(ret1.publisher)
    print(ret1.publisher.name)  #因为一对多的关系所以ret1.publisher是一个对象,而不是一个queryset集合

    # 反向查找
    ret2=models.Publish.objects.last()
    print(ret2.name)
    print(ret2.city)
    #如何拿到与它绑定的Book对象呢?
    print(ret2.book_set.all()) #ret2.book_set是一个queryset集合

#---------------了不起的双下划线(__)之单表条件查询----------------

#    models.Tb1.objects.filter(id__lt=10, id__gt=1)   # 获取id大于1 且 小于10的值
#
#    models.Tb1.objects.filter(id__in=[11, 22, 33])   # 获取id等于11、22、33的数据
#    models.Tb1.objects.exclude(id__in=[11, 22, 33])  # not in
#
#    models.Tb1.objects.filter(name__contains="ven")
#    models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
#
#    models.Tb1.objects.filter(id__range=[1, 2])   # 范围bettwen and
#
#    startswith，istartswith, endswith, iendswith,

#----------------了不起的双下划线(__)之多表条件关联查询---------------

# 正向查找(条件)

#     ret3=models.Book.objects.filter(title='Python').values('id')
#     print(ret3)#[{'id': 1}]

      #正向查找(条件)之一对多

      ret4=models.Book.objects.filter(title='Python').values('publisher__city')
      print(ret4)  #[{'publisher__city': '北京'}]

      #正向查找(条件)之多对多
      ret5=models.Book.objects.filter(title='Python').values('author__name')
      print(ret5)
      ret6=models.Book.objects.filter(author__name="alex").values('title')
      print(ret6)

      #注意
      #正向查找的publisher__city或者author__name中的publisher,author是book表中绑定的字段
      #一对多和多对多在这里用法没区别

# 反向查找(条件)

    #反向查找之一对多:
    ret8=models.Publisher.objects.filter(book__title='Python').values('name')
    print(ret8)#[{'name': '人大出版社'}]  注意,book__title中的book就是Publisher的关联表名

    ret9=models.Publisher.objects.filter(book__title='Python').values('book__authors')
    print(ret9)#[{'book__authors': 1}, {'book__authors': 2}]

    #反向查找之多对多:
    ret10=models.Author.objects.filter(book__title='Python').values('name')
    print(ret10)#[{'name': 'alex'}, {'name': 'alvin'}]

    #注意
    #正向查找的book__title中的book是表名Book
    #一对多和多对多在这里用法没区别
 
    
 
    View Code 
   
 
   
注意：条件查询即与对象查询对应，是指在filter，values等方法中的通过__来明确查询条件。
 
   
---------->聚合查询和分组查询
 
   
<1> aggregate(*args,**kwargs):
 
   
   通过对QuerySet进行计算，返回一个聚合值的字典。aggregate()中每一个参数都指定一个包含在字典中的返回值。即在查询集上生成聚合。
 
   
 
     
     
    
 
     
from django.db.models import Avg,Min,Sum,Max

从整个查询集生成统计值。比如，你想要计算所有在售书的平均价钱。Django的查询语法提供了一种方式描述所有
图书的集合。

>>> Book.objects.all().aggregate(Avg('price'))
{'price__avg': 34.35}

aggregate()子句的参数描述了我们想要计算的聚合值，在这个例子中，是Book模型中price字段的平均值

aggregate()是QuerySet 的一个终止子句，意思是说，它返回一个包含一些键值对的字典。键的名称是聚合值的
标识符，值是计算出来的聚合值。键的名称是按照字段和聚合函数的名称自动生成出来的。如果你想要为聚合值指定
一个名称，可以向聚合子句提供它:
>>> Book.objects.aggregate(average_price=Avg('price'))
{'average_price': 34.35}


如果你也想知道所有图书价格的最大值和最小值，可以这样查询：
>>> Book.objects.aggregate(Avg('price'), Max('price'), Min('price'))
{'price__avg': 34.35, 'price__max': Decimal('81.20'), 'price__min': Decimal('12.99')}
 
    
 
    View Code 
   
 
   
<2> annotate(*args,**kwargs):
 
   
   可以通过计算查询结果中每一个对象所关联的对象集合，从而得出总计值(也可以是平均值或总和)，即为查询集的每一项生成聚合。
 
   
       查询alex出的书总价格  
 
   
 
   
 
 
   
 查询各个作者出的书的总价格,这里就涉及到分组了，分组条件是authors__name
 
   
 
   
     查询各个出版社最便宜的书价是多少
 
   
 
   
---------->F查询和Q查询
 
   
仅仅靠单一的关键字参数查询已经很难满足查询要求。此时Django为我们提供了F和Q查询：
 
   
 
     
     
    
 
     
# F 使用查询条件的值,专门取对象中某列值的操作

    # from django.db.models import F
    # models.Tb1.objects.update(num=F('num')+1)


# Q 构建搜索条件
    from django.db.models import Q

    #1 Q对象(django.db.models.Q)可以对关键字参数进行封装，从而更好地应用多个查询
    q1=models.Book.objects.filter(Q(title__startswith='P')).all()
    print(q1)#[, ]

    # 2、可以组合使用&,|操作符，当一个操作符是用于两个Q的对象,它产生一个新的Q对象。
    Q(title__startswith='P') | Q(title__startswith='J')

    # 3、Q对象可以用~操作符放在前面表示否定，也可允许否定与不否定形式的组合
    Q(title__startswith='P') | ~Q(pub_date__year=2005)

    # 4、应用范围：

    # Each lookup function that takes keyword-arguments (e.g. filter(),
    #  exclude(), get()) can also be passed one or more Q objects as
    # positional (not-named) arguments. If you provide multiple Q object
    # arguments to a lookup function, the arguments will be “AND”ed
    # together. For example:

    Book.objects.get(
        Q(title__startswith='P'),
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
    )

    #sql:
    # SELECT * from polls WHERE question LIKE 'P%'
    #     AND (pub_date = '2005-05-02' OR pub_date = '2005-05-06')

    # import datetime
    # e=datetime.date(2005,5,6)  #2005-05-06

    # 5、Q对象可以与关键字参数查询一起使用，不过一定要把Q对象放在关键字参数查询的前面。
    # 正确：
    Book.objects.get(
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
        title__startswith='P')
    # 错误：
    Book.objects.get(
        question__startswith='P',
        Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)))
 
    
 
    View Code 
   
 
   
raw sql
 
   
django中models的操作,也是调用了ORM框架来实现的,pymysql 或者mysqldb,所以我们也可以使用原生的SQL语句来操作数据库!
 
   
九 admin的配置
 
   
admin是django强大功能之一，它能共从数据库中读取数据，呈现在页面中，进行管理。默认情况下，它的功能已经非常强大，如果你不需要复杂的功能，它已经够用，但是有时候，一些特殊的功能还需要定制，比如搜索功能，下面这一系列文章就逐步深入介绍如何定制适合自己的admin应用。
 
   
如果你觉得英文界面不好用，可以在setting.py 文件中修改以下选项
 
   
 
    
LANGUAGE_CODE = 'en-us'  #LANGUAGE_CODE = 'zh-hans'
 
   
 
   
一  认识ModelAdmin
 
   
   管理界面的定制类，如需扩展特定的model界面需从该类继承。
 
   
二 注册medel类到admin的两种方式：
 
   
     <1>   使用register的方法
 
   
 
    
admin.site.register(Book,MyAdmin)
 
   
 
   
  <2>   使用register的装饰器
 
   
 
    
@admin.register(Book)
 
   
 
   
三 掌握一些常用的设置技巧
 
   
 
    
    list_display:     指定要显示的字段
 
    
    search_fields:  指定搜索的字段
 
    
    list_filter:        指定列表过滤器
 
    
    ordering：       指定排序字段
 
   
 
   
 
     
     
    
 
     
from django.contrib import admin
from app01.models import *
# Register your models here.

# @admin.register(Book)#----->单给某个表加一个定制
class MyAdmin(admin.ModelAdmin):
    list_display = ("title","price","publisher")
    search_fields = ("title","publisher")
    list_filter = ("publisher",)
    ordering = ("price",)
    fieldsets =[
        (None,               {'fields': ['title']}),
        ('price information', {'fields': ['price',"publisher"], 'classes': ['collapse']}),
    ]

admin.site.register(Book,MyAdmin)
admin.site.register(Publish)
admin.site.register(Author)
 
    
 
    View Code 
   
 
   
 
 
   
在models.py建表
 
   
 
     
     
    
 
     
from django.db import models

# Create your models here.



class Book(models.Model):
    name=models.CharField(max_length=20)
    price=models.IntegerField()
    pub_date=models.DateField()
    publish=models.ForeignKey("Publish")
    author=models.ManyToManyField("Author")

    def __str__(self):
        return self.name


class Publish(models.Model):
    name=models.CharField(max_length=20)
    city=models.CharField(max_length=20)

    def __str__(self):
        return self.name

class Author(models.Model):
    name=models.CharField(max_length=20)
    age=models.IntegerField()

    def __str__(self):
        return self.name
 
    
 
    View Code 
   
 
   
在views.py
 
   
 
     
     
    
 
     
from django.shortcuts import render,HttpResponse
from django.db.models import Avg,Min,Sum,Max,Count
from django.db.models import Q,F

# Create your views here.

from app01.models import *


def addd(req):
    # 添加方法一
    # Book.objects.create(name="你的爸爸是谁",price=100,pub_date="2017-5-5",publish_id=1)

    # 添加方法二
    # p=Publish.objects.filter(name="重庆书店")[0]
    # Book.objects.create(name="我是你爸",price=10,pub_date="2027-1-5",publish=p)
    return HttpResponse("成功")


def select(req):
    # b=Book.objects.get(id=3)
    # print(b.name)
    # print(b.price)
    # print(b.publish.name)
    # print(b.publish.city)

    # b=Book.objects.filter()
    # b1=b.values("name","price")
    # return render(req,"select.html",locals())
    # print("b1",b1)
    # for i in b1:
    #     print(i["name"])

    # p=Publish.objects.filter(name="人民书店")[0]
    # p1=p.book_set.all()
    # p2=p1.values("name")
    # print("p2",p2)
    # for i in p2:
    #     print(i["name"])
    # return HttpResponse("111")


    # ret=Book.objects.filter(publish__name="重庆书店").values("name")
    # print(ret)

    # ret1=Publish.objects.filter(book__name="python").values("name")
    # print(ret1)
    # ret2=Book.objects.filter(name="python").values("publish__name")
    # print(ret2)

    # b=Book.objects.filter(author__name="alex").values("name","price","pub_date")
    # print(b)
    # for i in b:
    #     print(i["name"])
    #     print(i["price"])
    #     print(i["pub_date"])

     # 书的总价格
    # ret=Book.objects.all().aggregate(Sum("price"))
    # print(ret)

    # tom写的书的总价格
    # ret=Book.objects.filter(author__name="tom").aggregate(Sum("price"))
    # print(ret)


    #算每个作者的书的总价格
    # ret=Book.objects.values("author__name").annotate(Sum("price"))
    # print(ret)

    #  |或   ~非 要用Q
    # ret=Book.objects.filter(Q(name="go") | Q(price=54))
    # print(ret)

    #  F
    # Book.objects.filter(id=5).update(price=F("price")+100)

    return HttpResponse("111")
 
    
 
    View Code 
   
 
   
 
 
   
COOKIE和SESSION
 
   
 
     
     
    
 
     
from django.shortcuts import render,redirect

# Create your views here.


def login(req):
    print("COOKIES",req.COOKIES)
    print("SESSION",req.session)

    if req.method=="POST":
        name=req.POST.get("user")
        pwd=req.POST.get("pwd")
        if name=="liao" and pwd=="123":
            # ret=redirect("/index/")
            # ret.set_cookie("username",name)
            # return ret

            #COOKIE SESSION
            req.session["is_login"]=True
            req.session["user"]=name

            return redirect("/index")

    return render(req,"login.html")


def index(req):
    # if req.COOKIES.get("username",None):
    #     name=req.COOKIES.get("username",None)
    #     return render(req,"index.html",locals())

    if req.session.get("is_login",None):
        name=req.session.get("user",None)
        return render(req,"index.html",locals())
    else:
        return redirect("/login/")
 
    
 
    View Code 
   
 
   
 
 
   
  
转载于:https://www.cnblogs.com/liaoboshi/p/6498137.html
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    

                        
                        

                            
 
                        
                        
                        

                            

                        
                        
                        

                            

                        
                    
                
            
        
    
    

        
你可能感兴趣的:(django2)
        

            

                

                    
【linux开发环境配置】 Ubuntu 17.10 安装Django2 基础
                        NewForMe

                        
前言1首先Ububtu默认是安装了python2.7，所以我要重新安装python3,linux下单独安装python3的教程可再百度，一般就是在终端下执行命令sudoapt-getinstallpython3,有可能会因本来装有python2而不成功，所以可能需要删除usr/bin/目录下的python文件,然后重新执行上面的命令。2我是直接安装Anaconda3的，直接安装Anaconda3里
                    
                    
django2前后端分离——restful
                        玩蛇的胖纸

                        
restful规范（建议）1.根据method不同做不同的操作基于FBVurlpatterns=[path('order/',views.order),]deforder(request):ifrequest.method=="GET":returnHttpResponse('获取订单')elifrequest.method=="POST":returnHttpResponse('创建订单')el
                    
                    
Django2.0.5安装Xadmin方法
                        SimonDM

                        
方法一：1、打开github，搜索xadmin2、进入主页，下拉，找到GetStarted-->INSTALL，在cmd中输入：pipinstallgit+git://github.com/sshwsfc/xadmin.git@django23、PC端需要安装Git，并且，由于是从github上clone的，文件稍大速度会非常慢。方法二：1、进入django2分支clone下载：2、解压后将xad
                    
                    
django2与ajax,Python-Django-Ajax进阶2
                        一枝清荷
django2与ajax
                        
-forms组件的渲染错误信息在模板中:{{foo.errors.0}}-forms使用bootstrap样式widget=widgets.EmailInput(attrs={'class':'form-control'}))-全局和局部钩子函数AOP:面向切面编程-局部钩子函数(再校验name)defclean_name(self):#从cleaned_data中取出字段的值name=self.
                    
                    
Django学习日志04
                        safvirtu
django学习python
                        
路由层url(r'^test/$',views.test),url(r'testadd',views.testadd),##首页的地址url(r'^$',views.home),#django2中path('admin/',admin.site.urls),#精准匹配，不支持正则表达式path('test/',views.test),#精准匹配，不支持正则表达式re_path(r'^test/$'
                    
                    
day55
                        小小史迪仔
django
                        
今日内容概要路由层无名分组有名分组反向解析无名分组反向解析有名分组反向解析路由分发伪静态的概念(了解)名称空间(了解)虚拟环境(了解)django1.x和django2.x的区别路由层url(r'^test/$',views.test),url(r'testadd',views.testadd),##首页的地址url(r'^$',views.home),#django2中path('admin/'
                    
                    
Django路由层之有名分组和无名分组、反向解析、路由分发、伪静态的概念、名称空间、虚拟环境、Django1和Django2的区别
                        m0_69962105
djangopython后端
                        
【1】无名分组无名分组：就是把正则中小括号里噩匹配到的内容以位置参数的形式传递给视图函数url(r'^test/(\d+)$',view.text)get请求的第一种方式：http://127.0.0.1:8000/test/?a=1&b=2get请求的第二种方式：http://127.0.0.1:8000/test/12/1【2】有名分组有名分组：就是把正则中括号里的匹配的内容以关键字参数的形式
                    
                    
计算机基础知识51
                        糖果爱上我
前端数据库javascript
                        
路由层(urls.py)url(r'^test/$',views.test),url(r'testadd',views.testadd),#首页的地址url(r'^$',views.home),#url方法的第一个参数支持的是正则表达式#django2中path('admin/',admin.site.urls),#精准匹配，不支持正则表达式path('test/',views.test),#精准
                    
                    
Django（四、路由层）
                        A_baio
Djangodjangosqlite数据库
                        
文章目录一、路由层1.路由匹配url方法第一个是参数的正则表达式二、正则无名分组与有名分组无名分组有名分组三、反向解析1.概念无名分组动态路由解析有名分组动态路由解析四、路由分发为什么要用路由分发？1.总路由分发配置名称空间五、伪静态的概念六、虚拟环境什么是虚拟环境？如何创建虚拟环境？django1和django2的区别1.路由文件Django默认支持以下5个转化器：一、路由层1.路由匹配Djan
                    
                    
Django之路由层
                        ζ浅安时光
django数据库python
                        
目录一、路由层二、无名分组三、有名分组四、反向分析1.无名分组反向解析2.有名分组反向分析五、路由分发六、名称空间(了解)七、伪静态的概念(了解)八、虚拟环境(了解)九、Django1和Django2的区别1.路由文件2.创建表关系一、路由层Django1中url(r'^test/$',views.test),url(r'testadd',views.testadd),#首页的地址url(r'^$
                    
                    
django2 快速安装指南
                        入沐三分
django2文档DjangoPython入沐三分
                        
django2快速安装指南1.安装作为一个PythonWeb框架，Django需要Python的支持。请参阅我可以在Django中使用哪些Python版本？了解详情。Python包含一个名为SQLite轻量级的数据库，因此你不需要设置数据库。请通过https://www.python.org/downloads/或操作系统的软件包管理器获取最新版本的Python。你可以通过Python从shell
                    
                    
django 博客 mysql 示例_Django2练习项目：开发个人博客系统（1）
                        雄鹰财经
django博客mysql示例
                        
从这一篇教程开始，我们一起结合以往学过的知识内容，完成一个简单的个人博客系统。当然，在开发的过程中，仍然会有更多的新鲜知识点的融入，让我们掌握更多的知识内容。这里要开发的个人博客系统功能比较简单，主要包括文章、分类、标签、评论、搜索、分页以及侧边栏的实现。还有就是，结合Bootstrap这个前端框架，让博客系统的界面美观，并且完成导航栏和页面底部内容。这一篇教程，我们先完成数据模型。首先，需要安装
                    
                    
pycharm创建Django项目以及运行过程（以一个简易博客系统为例）
                        bky01
pythonpythonDjango
                        
一、条件准备需要事先准备的就是python3、Django2以及pycharm和MySQL的安装，建议安装MySQL5.7及以上的版本，这里我主要讲的是Django项目的创建以及执行过程，安装过程我这里就不再讲解了。二、创建过程1、Django项目创建：在pycharm中，File→NewProject→Django，如下如中所示create之后，稍等片刻后会创建成功，项目的目录如下：接下来，我为
                    
                    
Django2 web实战01-启动项目
                        weixin_34015336
python前端数据结构与算法ViewUI
                        
作者：Hubery时间：2018.7.240前言=瞎说能写web的语言有好多。python算是难度较低，入门较快的脚本语言。Django是python的web框架，详情不多叙，见：Django-wiki介绍#Django历史---------->>>>>这段可以不看。在Web早期阶段，开发者手动编写每个页面。更新网站要编辑HTML;重新设计要重新制作每一个网页，而且一次只能改一个网页。随着网站体量
                    
                    
django2前后端分离——前言
                        玩蛇的胖纸

                        
初识前后端分离对于Python全栈开发工程师来说，使用django开发整个网站项目，是一件再普通不过的事儿了，django强大的模板系统，并没有足以让一个全栈开发工程师觉得有必要搞什么前后端分离，但术业有专攻，一个后端，可以对应不同的前端（比如pc网页端，手机wap端，移动端app，微信小程序……），往往公司的业务需求，都是需要各个流量入口都有的全家桶，如果让全栈工程师，不断开发后端，还要一个一个
                    
                    
No module named ‘crispy_forms‘
                        静水深流~
python
                        
我在最近的django开发过程中遇到一些问题，就是我在github上下载xadmin源码包之后，然后setings之中也进行了配置，出现了如下问题:解决方法：pipinstalldjango-crispy-forms其他模块一样如此然后我给他大家提供了一个xadmin新版的下载地址https://github.com/sshwsfc/xadmin/tree/django2这样xadmin就能运行了
                    
                    
Django--Laboratory drug management and early warning system
                        轻览月
djangopythonmysql
                        
Createanewcondaenvironment：E:\program\anaconda3\envs\Django2\python.exe-mpipinstall-rrequirements.txtsource~\lms.sqlpythonmanage.pymakemigrationspythonmanage.pymigratepythonmanage.pyrunserverExampleCr
                    
                    
Django2 SQLite3迁移到MySQL数据库
                        吾星喵
Web开发SQLiteMySQLD叫阿公弄
                        
更多内容请点击我的博客查看，欢迎来访。Django2SQLite3迁移到MySQL数据库开发环境Windows+Django2.1+Python3.7，服务器环境Ubuntu16.04+Django2.1+Python3.6.6Windows开发环境下创建mysql连接配置文件该文件可保存在本机任何地方，如果项目要上传到github上或其他共享，mysql帐密不可能让别人知道呀ProjectCon
                    
                    
Django2自动获取项目中的全部URL
                        hj009zzh
pythondjangodjangopython
                        
项目开发中，需要查看检查所有的URL，一个一个url文件检查不方便，且有fbv的接口还有cbv的接口，不方便检查，于是写了个脚本获取所有接口urlfromdjango.urls.resolversimportURLResolver,URLPatterndefrecursion_urls(pre_namespace,pre_url,_urlpatterns,url_list:list):"""递归的
                    
                    
django2笔记:路由path语法
                        帅气的猪猪

                        
9月23，Django发布了2.0a1版本，这是一个featurefreeze版本，如果没有什么意外的话，2.0正式版不会再增加新的功能了。按照以往的规律，预计正式版将在12月发布。备注：Django2.0于12月2日已经正式发布。（链接）2.0无疑是一个里程碑版本，移除了对Python2.7的支持，最少需要3.4以上，建议使用3.5以上的版本。What’snewinDjango2.0文档中一共列
                    
                    
Django2
                        文化银儿

                        
视图1使用指南前言MVT模式中的V，V代表视图，在Django中的视图主要用来接受web请求，并做出响应。视图的本质就是一个python中的函数视图的响应分为两大类以json数据形式返回以网页的形式返回重定向到另一个网页错误视图页面（404,500等）视图响应的过程：浏览器输入→django获取信息并去掉ip：端口，身下路径→urls路由匹配→视图响应→回馈到浏览器1.url配置1.1配置流程se
                    
                    
python web django开发教程_Django2：Web项目开发入门笔记（7）
                        大宝宝和小宝贝
pythonwebdjango开发教程
                        
这一篇教程，我们一起来学习Django2中模型的使用。提示：为了更顺利的学习新的内容，建议大家在PyCharm中重新创建项目和应用。在之前的教程中，我们已经知道模型(Model)是和数据库相关的。Django支持多种数据库，包括默认的SQLite3以及MySQL和PostgreSQL等数据库。使用哪一种数据库需要在项目的settings.py中进行进行配置。如果使用默认的SQLite3数据库，这个
                    
                    
django2集成DjangoUeditor富文本编辑器
                        li_changyuan

                        
官方的不支持python3,可以去慕课网给的一个链接去下载。https://github.com/liyaopinner/mxonline_resources
                    
                    
解决django.core.exceptions.ImproperlyConfigured: mysqlclient 1.4.3 or newer is required； you have 1.0.
                        JiayinX
djangopython后端
                        
最近在配置环境时遇到这样的问题在网上查找了很多资料，比如注释base.py中的代码，又或是添加如下代码：这些方法对我来说都不管用，后面又查到说可以降低django的版本。随后我重新安装了django2的版本，然后报以下错误：TypeError:argumentoftypePosixPathisnotiterable网上查找资料说时django版本太低，与python3不兼容。随后我将django版
                    
                    
django2
                        进击的豌豆

                        
一.MVC/MTV介绍MVC的全拼为Model-View-Controller，最早由TrygveReenskaug在1978年提出，是施乐帕罗奥多研究中心(XeroxPARC)在20世纪80年代为程序语言Smalltalk发明的一种软件设计模式，是为了将传统的输入（input）、处理（processing）、输出（output）任务运用到图形化用户交互模型中而设计的。随着标准输入输出设备的出现，
                    
                    
django利用自带的认证模块配置用户登陆认证
                        lsysafe
djangopython后端
                        
环境django2或者3改动几个配置1.views.pyfromdjango.contrib.auth.decoratorsimportlogin_required在需要认证身的的方法的前一行@login_required2.urls.pyfromdjango.contrib.auth.viewsimportlogin#测试django3使用这种fromdjango.contrib.authimp
                    
                    
6. Web应用程序Django2——用户账户1
                        YangDxg

                        
1.让用户能够输入数据添加几个页面，让用户能够输入数据，能够添加新主题，添加新条目以及编辑既有条目只有超级用户能够通过管理网站输入数据，为了不让用户与管理网站交互，因此使用Django的表单创建工具来创建让用户能够输入数据的页面添加新主题创建基于表单的页面方法与创建网页方法基本一致定义一个URL编写一个视图函数编写一个模版基于表单的页面需要导入包含表单的模块forms.py创建一个名为forms.
                    
                    
社区版PyCharm安装并创建Django项目
                        大太阳花花公主
webdjango
                        
目录1，下载Django2，创建Django项目3，创建应用。4，启动项目5，关于报错1，下载Django首先点击左上角的file选择setting，然后按照下方操作下载Django。出现下方所示情形表示Django下载成功。那么Django下载好了之后该怎么使用呢？由于我的是社区版，且Windows版本是Win7，所以显然不能利用pycharm直接创建Django项目，也不能利用cmd来直接创建
                    
                    
django框架下 messages方法详解 弹窗功能的实现
                        城南望余雪
djangopythondjango
                        
项目场景：提示：这里简述项目相关背景：关于实现django框架下实现页面弹窗功能解决方案：1、查看主项目settings.py中INSTALLED_APPS中messages配置信息是否存在（django2以后均在默认值）INSTALLED_APPS=['django.contrib.admin','django.contrib.auth','django.contrib.contenttypes
                    
                    
Django学习
                        回首思
django学习python
                        
Django学习1创建项目终端：django-adminstartproject项目名Pycharm：新建项目选择Django2默认文件介绍HelloWorld|--HelloWorld||--__init__.py||--asgi.py[接收网络请求](不用动)||--settings.py[项目配置](经常使用)||--urls.py[URL和函数的对应关系](经常使用)|`--wsgi.py
                    
                                
tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
                                
                                
网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
                                
                                
[信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
 
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
                                
                                
使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
*首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
                                
                                
大访问量高并发
                                    oloz
大访问量高并发
                                    
大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
                                
                                
cache 服务器
                                    小猪猪08
cache
                                    
Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
                                
                                
mysql存储过程
                                    香水浓
mysql
                                    
Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
                                
                                
CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
  CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
                                
                                
全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
                                
                                
MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
                                
                                
JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
    在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
                                
                                
AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
        如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
                                
                                
[Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
                                
                                
【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
  1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
                                
                                
linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
                                
                                
unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
                                
                                
线段树-入门
                                    bylijinnan
java算法线段树
                                    



/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
                                
                                
全选与反选
                                    chicony
全选
                                    
  
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

                                
                                
vim一些简单记录
                                    chenchao051
vim
                                    
mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
                                
                                
Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
[size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
                                
                                
php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
                                
                                
SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
                                
                                
对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
                                
                                
同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
                                
                                
Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
                                
                                
Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
                                
                                
对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
                                
                                
xml 验证
                                    pengfeicao521
xmlxml解析
                                    
有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
                                
                                
div设置半透明效果
                                    spjich
css半透明
                                    
为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
                                
                                
你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
    单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
                                
                
            
        
    


    

        

            按字母分类：
            ABCDEFGHIJKLMNOPQRSTUVWXYZ其他
        
    


    

        

            首页 -
            关于我们 -
            站内搜索 -
            Sitemap -
            侵权投诉
        
        
版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.