Day20 Django的使用_基础

老师网址：

https://www.cnblogs.com/yuanchenqi/articles/7652353.html

1，复习上级课，一对一，一对多，多对多的使用

models.py: 

class Book(models.Model):

    nid=models.AutoField(primary_key=True)
    title=models.CharField(max_length=)

    # 书籍与出版社： 一对多
    publisher=models.ForeignKey(to="Publish",related_name="bookList")

    # 书籍与作者： 多对多
    authors=models.ManyToManyField("Author")

class Publish(models.Model):

    name=models.CharField(max_length=)

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

class AuthorDetail(models.Model):

    addr=models.CharField(max_length=)
    author=models.OneToOneField("Author")

、单表查询

       models.Book.obejcts.all()       #   QuerySet    []
       models.Book.obejcts.filter(nid__gt=,nid__lt=)  #   QuerySet   []
       models.Book.obejcts.get()       # model对象
       models.Book.obejcts.values()     #   QuerySet   [{},{}]
       models.Book.obejcts.values_list()
       models.Book.obejcts.exclude()
       models.Book.obejcts.all().first()
       models.Book.obejcts.all().last()
       models.Book.obejcts.all().orderby()
       models.Book.obejcts.all().reverse()
       models.Book.obejcts.values("price").distinct()
       models.Book.obejcts.all().count()
       models.Book.obejcts.all().exist()   

       ---- 双下划线：
        models.Book.obejcts.filter(nid__gt=)
        models.Book.obejcts.filter(price__in=[,,])    

    支持链式操作：
         models.Book.obejcts.all().filter().orderby("id").count()
         models.Book.obejcts.all().get().orderby("id").count() 

、跨表查询

   ----  基于对象

         () 查询Linux这本书的出版社名称和作者名字   属于正向查询  按关联字段
             book_obj=models.Book.obejcts.get(title="linux")
             book_obj.publisher.name

             authors_list=book_obj.authors.all()
             for author in authors_list:
                 print(author.name)    

         () 人民出版社出版过的所有书籍名称   属于反向查询  if 设置related_name，那么related_name的值，没有设置，按表明_set
             publish_obj=models.Publish.obejcts.filter(name="人民出版社").first()
             book_list=publish_obj.bookList.all()
             for book in book_list:
                  print(book.title)

         () alex 出版社过得所有书籍的名称    属于反向查询 if 设置related_name，那么related_name的值，没有设置，按表明_set
             alex=models.Author.obejcts.get(name="alex")
             book_list=alex.book_set.all()
             for book in book_list:
                  print(book.title)    

         () 作者alex的所在地址  正向查询 按字段  反向查询 按表名
             alex=models.Author.obejcts.get(name="alex")
             alex.authordetail.addr

    ----  基于QuerySet   双下划线：   正向查询：按字段     反向查询：按表名    key：   过滤条件   查询结果

         () 查询Linux这本书的出版社名称和作者名字   属于正向查询  按关联字段

             models.Book.obejcts.filter(title="linux").values("publisher__name") # [{"publisher__name":"人民出版社"}]
             models.Book.obejcts.filter(title="linux").values("authors__name")   #

         () 人民出版社出版过的所有书籍名称 

             models.Book.obejcts.filter(publisher__name="人民出版社").values("title")

             models.Publish.obejcts.filter(name="人民出版社").values("book__title")         

         () alex 出版社过得所有书籍的名称

             models.Book.obejcts.filter(authors__name="alex").values("title")

             models.Author.obejcts.filter(name="alex").values("book__title")

2，分页怎么做的：

如果说短时间内一条条的添加数据的话，可能会造成服务器压力太大。

可以将要创建的数据打包，然后在一起放入数据库。

def add(request):
    Booklist = []
    for i in range():
        book_obj=models.Book(title="book" + str(i), price= + i * i)
        Booklist.append(book_obj)

    models.Book.objects.bulk_create(Booklist)

先引用一个变量：

from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger

paginator(book_list,8)

# book_list:是你要分页的数据

#  8： 每页数据的条数

'''
分页器的使用:
    book_list=Book.objects.all()
    paginator = Paginator(book_list, )
    print("count:",paginator.count)           #数据总数
    print("num_pages",paginator.num_pages)    #总页数
    print("page_range",paginator.page_range)  #页码的列表

    page1=paginator.page() #第1页的page对象
    for i in page1:         #遍历第1页的所有数据对象
        print(i)
    print(page1.object_list) #第1页的所有数据

    page2=paginator.page()

    print(page2.has_next())            #是否有下一页
    print(page2.next_page_number())    #下一页的页码
    print(page2.has_previous())        #是否有上一页
    print(page2.previous_page_number()) #上一页的页码

    # 抛错
    #page=paginator.page()   # error:EmptyPage
    #page=paginator.page("z")   # error:PageNotAnInteger

    '''

可以利用bootstrap来进行样式改：

怎么遍历显示图标数字：

{% for i in page_range %}
    <li><a href="/?p={{i}}">{{i}}></a></li>
{% endfor %}

shangyiye:

xiayiye:

3， cookie和session：

    cookie： 保留在客户端（浏览器）的存放键值对的容器  {"":""}    

    session： 保留在服务器上的一个容器     {"":""}         

    def login:
         if :
             request.session["is_login_egon"]=True
             request.session["username"]="alex"

             # 赋值session实现了什么
             () django---写好响应cookie：{"sessionID":"123asdas12312"}
             () dajngo--- 在django-session表中创建一条记录

                        session-key      session-data
                       123asdas12312    {"is_login_egon":True,"username":"alex"}

    def index:
             if not request.session.get("is_login_egon"):
                  # 取值session ,实现了什么
                  () dajngo-- 先获取cookie的sessionID： 123asdas12312
                  () django---ret=models.django_session.objects,filter(session-key="123asdas12312")

                  () 我们自己实现的：ret["is_login_egon"]   

                  return redirect("/login/")

    {"sessionID"L:""}

    会话---session
    注销---清除session
           request.session.flush()

                  () dajngo-- 先获取cookie的sessionID： 123asdas12312
                  () django---ret=models.django_session.objects.filter(session-key="123asdas12312")

                  () flush：ret.delete()
           

4,auth模块

直接在Terminal中可以创建用户：

python manage createsuperuser

auth的引入：

from django.contrib import auth

 、authenticate()   

提供了用户认证，即验证用户名以及密码是否正确,一般需要username  password两个关键字参数

如果认证信息有效，会返回一个  User  对象。authenticate()会在User 对象上设置一个属性标识那种认证后端认证了该用户，且该信息在后面的登录过程中是需要的。当我们试图登陆一个从数据库中直接取出来不经过authenticate()的User对象会报错的！！

user =authenticate(username='someone',password='somepassword')

注销页面:

 、login(HttpRequest, user)　　

该函数接受一个HttpRequest对象，以及一个认证了的User对象

此函数使用django的session框架给某个已认证的用户附加上session id等信息。

from django.contrib.auth import authenticate, login

def my_view(request):
  username = request.POST['username']
  password = request.POST['password']
  user = authenticate(username=username, password=password)
  if user is not None:
    login(request, user)
    # Redirect to a success page.
    ...
  else:
    # Return an 'invalid login' error message.
    ...
 、logout(request) 注销用户　　

from django.contrib.auth import logout

def logout_view(request):
  logout(request)
  # Redirect to a success page.
该函数接受一个HttpRequest对象，无返回值。当调用该函数时，当前请求的session信息会全部清除。该用户即使没有登录，使用该函数也不会报错。

 、user对象的 is_authenticated()

要求：

  用户登陆后才能访问某些页面，

  如果用户没有登录就访问该页面的话直接跳到登录页面

  用户在跳转的登陆界面中完成登陆后，自动访问跳转到之前访问的地址

方法1:

def my_view(request):
  if not request.user.is_authenticated():
    return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
方法2:

django已经为我们设计好了一个用于此种情况的装饰器：login_requierd()

from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
  ...
若用户没有登录，则会跳转到django默认的 登录URL '/accounts/login/ ' (这个值可以在settings文件中通过LOGIN_URL进行修改)。并传递  当前访问url的绝对路径 (登陆成功后，会重定向到该路径)

5,session配置：

数据库配置：

Django默认支持Session，并且默认是将Session数据存储在数据库中，即：django_session 表中。

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.db'   # 引擎（默认）

    SESSION_COOKIE_NAME ＝ "sessionid"                       # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串（默认）
    SESSION_COOKIE_PATH ＝ "/"                               # Session的cookie保存的路径（默认）
    SESSION_COOKIE_DOMAIN = None                             # Session的cookie保存的域名（默认）
    SESSION_COOKIE_SECURE = False                            # 是否Https传输cookie（默认）
    SESSION_COOKIE_HTTPONLY = True                           # 是否Session的cookie只支持http传输（默认）
    SESSION_COOKIE_AGE =                              # Session的cookie失效日期（2周）（默认）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                  # 是否关闭浏览器使得Session过期（默认）
    SESSION_SAVE_EVERY_REQUEST = False                       # 是否每次请求都保存Session，默认修改之后才保存（默认）

缓存配置：

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.cache'  # 引擎
    SESSION_CACHE_ALIAS = 'default'                            # 使用的缓存别名（默认内存缓存，也可以是memcache），此处别名依赖缓存的设置

    SESSION_COOKIE_NAME ＝ "sessionid"                        # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                              # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                             # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                            # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE =                               # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                   # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                        # 是否每次请求都保存Session，默认修改之后才保存

文件配置：

a. 配置 settings.py

    SESSION_ENGINE = 'django.contrib.sessions.backends.file'    # 引擎
    SESSION_FILE_PATH = None                                    # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()
    SESSION_COOKIE_NAME ＝ "sessionid"                          # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
    SESSION_COOKIE_PATH ＝ "/"                                  # Session的cookie保存的路径
    SESSION_COOKIE_DOMAIN = None                                # Session的cookie保存的域名
    SESSION_COOKIE_SECURE = False                               # 是否Https传输cookie
    SESSION_COOKIE_HTTPONLY = True                              # 是否Session的cookie只支持http传输
    SESSION_COOKIE_AGE =                                 # Session的cookie失效日期（2周）
    SESSION_EXPIRE_AT_BROWSER_CLOSE = False                     # 是否关闭浏览器使得Session过期
    SESSION_SAVE_EVERY_REQUEST = False                          # 是否每次请求都保存Session，默认修改之后才保存