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，默认修改之后才保存