Python框架☞Django

settings.py文件

#默认使用sqlite3数据库
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

#使用其他数据库连接
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': '127.0.0.1',
        'PORT': '5432',
    }
}

ENGINE包括：
'django.db.backends.postgresql'
'django.db.backends.mysql'
'django.db.backends.sqlite3'
'django.db.backends.oracle'


********注意*******
django默认使用MySQLdb模块连接mysql
python3中没有MySQLdb模块
所以django中连接mysql时需要如下操作：
在project同名下的__init__文件操作：
import pymysql
pymysql.install_as_MySQLdb()

详情参看：https://docs.djangoproject.com/en/2.2/ref/settings/#databases

# 全部字段：
__all__ = [
    'AutoField', 'BLANK_CHOICE_DASH', 'BigAutoField', 'BigIntegerField',
    'BinaryField', 'BooleanField', 'CharField', 'CommaSeparatedIntegerField',
    'DateField', 'DateTimeField', 'DecimalField', 'DurationField',
    'EmailField', 'Empty', 'Field', 'FieldDoesNotExist', 'FilePathField',
    'FloatField', 'GenericIPAddressField', 'IPAddressField', 'IntegerField',
    'NOT_PROVIDED', 'NullBooleanField', 'PositiveIntegerField',
    'PositiveSmallIntegerField', 'SlugField', 'SmallIntegerField', 'TextField',
    'TimeField', 'URLField', 'UUIDField',
]

# 常用字段介绍
 ##############
AutoField 
BooleanField 
DateField #日期类型 date 
DateTimeField #日期类型 datetime 
CharField URLField # 数据库中是String类型 
EmailField # 数据库中是String类型 
FloatField 
IntegerField ....

# 字段参数
verbose_name=None
name=None
primary_key=False
max_length=None
unique=False
blank=False
null=False,
db_index=False, 
rel=None, 
default=NOT_PROVIDED, 
editable=True,
serialize=True, 
unique_for_date=None, 
unique_for_month=None,
unique_for_year=None, 
choices=None, 
help_text='', 
db_column=None,
db_tablespace=None, 
auto_created=False,
validators=(),
error_messages=None


# 字段参数解释
null： 数据库中是否可以为空
default： 默认值
primary_key： 主键
db_column: 数据库中表的列名
db_index: 字段是否为索引
unique： 唯一索引
choices: django admin中显示下拉框；  避免链表查询（链表查询效率低）
    user_type_choices = (
        (1, '管理员'),
        (2, '运维'),
        (3, '普通用户')
    )
    user_type_id = models.IntergerField(choices=user_type_choices)
auto_now: 更新时自动生成
auto_now_add: 创建时 自动更新为当前时间
blank： django admin中是否可以为空
verbose_name:  django admin中是显示中文
editable： django admin中是否可以编辑
error_messages: django admin中是输入错误时提示语, 语法 error_messages={'required':'请输入信息'}
help_text:  django admin中提示
validators: django form 自定义错误信息
to： 外键&多对多关联的表
on_delete: 外键必传参数，对应的value有(CASCADE、PROTECT、DO_NOTHING、SET、SET_NULL、SET_DEFAULT)
CASCADE:
PROTECT:
SET_NULL: 需要设置同时设置null=True
SET_DEFAULT： 需要同时设置default的值
DO_NOTHING：
SET(): 需要设置一个默认值
from django.conf import settings
from django.contrib.auth import get_user_model
from django.db import models

def get_sentinel_user():
    return get_user_model().objects.get_or_create(username='deleted')[0]

class MyModel(models.Model):
    user = models.ForeignKey(
        settings.AUTH_USER_MODEL,
        on_delete=models.SET(get_sentinel_user),
    )

 

1. 独立表， 跟其他表没有关联
2. 一对多关系创建表，使用ForeignKey字段
3. 多对多关系创建表：
    方法1.自定义第三章表【使用外键】，表的列数无限制
    方法2.django帮助写第三章表，使用ManyToManyField字段，列限制只有3列；models.ManyToManyField(to="FOO")

 

 

# django项目，数据库中表名默认是按照 appName_modelsName 小写命名的，如果想修改数据库的表名 则需要在models中添加如下代码

class Roles(models.Model):
    """
        角色表
    """
    title = models.CharField(max_length=16, null=False, db_column="name")

    # 添加如下代码,数据库中表的名称就变为roles
    class Meta:
        db_table = "roles"

# 获取choices显示值语法：  get_FOO_display()

# models结构
from django.db import models

class User(models.Model):
    username = models.CharField(max_length=32, null=False)
    password = models.CharField(max_length=32, default=123456)
    nickname = models.CharField(max_length=64, unique=True, null=False)
    sex = (
        (1, '男'),
        (2, '女'),
    )
    femal = models.IntegerField(default=1, choices=sex)

    def __str__(self):
        return self.nickname

# 数据库中信息
id     username  password  nickname   femal
1    yunzhong    123456    流星               1
2    anjing    123456    静好               2
3    mingbai    666666    明白               1



# 获取choices的值
obj = User.objects.all()
for item in obj:
    print(item.nickname, item.get_femal_display())

 

 

跨表查询分为：正向查询&反向查询
正向查询：class中有ForeignKey 或者 ManyToManyField字段，这张表通过外键 或者 多对多关系跨向另外一张表进行查询，这种查询可以理解为正向查询

方向查询：class被其他class关联，但表中没有ForeignKey 或  ManyToManyField字段，通过表名小写_set 跨向另外一张表（这里小写的表名指的是主动关联的表名），这种查询可以理解为反向查询

正向跨表查询方式：
1. foreignKey__field       # 双下划线, values、values_list使用
2. obj.foreign_key.field   #all()查询之后，继续打印输入

反向跨表查询方式:
1. 表名小写_set   # all()查询，然后打印输出，实际使用 表名小写_set.all()     
2. 表名小写         # values_list、 values   
3. 表名小写__field   # values、 values_list

 

django路由配置支持三种形式：
1. FBV（function base view）
2. CBV（class base view）
3. Including another URLconf

一、FBV配置
*****urls.py code*****
from django.urls import path
from app01 import views
urlpatterns = [
    path('go/', views.go_to),
]

*****views code*****
def go_to(request):
    pass
    
二、CBV配置
*****urls.py code*****
from django.urls import path
from business import views
urlpatterns = [
    path('message/', views.Message.as_view(), name='message'), # name用于反向生成url
]

*****views code*****
# 此处的class需要继承View类
from django.views import View
class Message(View):

    def dispatch(self, request, *args, **kwargs):
        """
        用于分发请求，不同的请求调用不同的method
        :param request:
        :param args:
        :param kwargs:
        :return:
        """
        pass

    def get(self):
        pass

    def post(self):
        pass
        
三、Including another URLconf配置有2种方案
方案1：全部配置在主项目的urls.py中
方案2：主项目urls.py和 app中均需要配置

具体实现:
1.全部在主项目urls.py中配置
from business import views as busin_views
extra_patterns = [
    path('reports/', busin_views.report, {'blog_id': 3}),
]

urlpatterns = [
    path('business/', include(extra_patterns)),
]

2.主项目urls.py和 app中均需要配置
***主项目urls.py code*****
urlpatterns = [
    path('crm/', include('crm.urls', namespace='crm_reverse')),
]

***app中需要创建一个urls.py 内部code*******
from django.urls import path, re_path, include
from . import views

app_name = 'crm'

urlpatterns = [
    path('', views.home),
    path('read/', views.read),
]

=========================
django路由系统还支持正则、传参、反向生成URL、去除冗余等配置
from django.urls import path, register_converter 
register_converter(converters.FourDigitYearConverter, 'yyyy')  #自定义参数使用
urlpatterns = [
    path('admin/', admin.site.urls),
    path('message/', views.Message.as_view(), name='message'),
    path('home/<int:year>/<int:month>/', views.home, name='home_page'),  # name用于反向生成URL
    path('index/<slug:slug>/', views.index, name='reverse_index'), #slug指非固定格式

    path('articles/<yyyy:year>/', views.year_archive, {'foo': 'bar'}),  # yyyy为自定义参数类型，需要结合其他代码

    re_path(r'^luck/([0-9]{4})/', views.luck),  # 元组形式传参
    re_path(r'^lucy/(?P<year>[0-9]{4})/', views.lucy),  # 字典形式传参
    re_path(r'^comments/(?:page-(?P<page_number>\d+)/)?$', views.comments),
    path('hello/django/', include([           # 去除冗余
            path('history/', views.history),
            path('edit/', views.edit),
        ])),
]


自定义参数类型对应converters code：
class FourDigitYearConverter:
    regex = '[0-9]{6}'

    def to_python(self, value):
        return int(value)

    def to_url(self, value):
        return '%04d' % value

 

 

cookie & session
{
http是短连接
cookie：
    独立存在，用户浏览器上存储的键值对， cookie跟登陆没直接关系
    以后每次请求 都会带着以前的cookie
    所有系统--->用户登录是基于cookie做的
    基于cookie可以做用户认证
    cookie的来源： 服务端设置
    关键信息保存在cookie，会泄漏 会被篡改
        
session
    服务器端保存的键值对，键值对的key是随机字符串
    用户请求过来后，用户的cookie中会携带随机字符串
        
    Django框架中session支持保存位置：缓存、缓存+数据库、文件、数据    库、加密cookie； 默认保存在数据库
    默认不支持redis，支持memcache
    Django中session的有效期默认是2周，可以在setting中进行配置
    """
    Django中的request.session['user']= u 会同时做如下事情：    
    1.生成随机字符串
    2.发给客户端
    3.保存在服务端
    4.并在服务端写用户名
    """
        
    django_session可设置de点：
    1.session_id
    2.是否基于安全传输(https)
    3.cookie是否可以修改
    4.cookie有效时间
    5.关闭浏览器 cookie是否自动失效
    6.cookie全站生效
    7.是否每次请求都保存cookie
    ...
    
    网站注销：
    注销前 需要清除session  # request.session.clear()
}

在setting中设置Django的session：
SESSION_ENGINE
SESSION_COOKIE_AGE
SESSION_COOKIE_DOMAIN
SESSION_COOKIE_NAME
SESSION_COOKIE_PATH
SESSION_COOKIE_SECURE
SESSION_EXPIRE_AT_BROWSER_CLOSE
SESSION_SAVE_EVERY_REQUEST
SESSION_FILE_PATH
SESSION_CACHE_ALIAS  # using cache-based session storage, this selects the cache to use.

详情参考：   https://docs.djangoproject.com/en/2.2/ref/settings/#session-cookie-httponly

 

 

django后端可以分为3部分：中间件、路由、视图函数
    
中间件在django中的本质就是一个类
    
注意：中间件中的process_reponse function必须有返回值
    
中间件的作用：
1. 获取用户IP，黑名单中的IP不允许访问视图函数
2. 记录用户访问日志
3. 记录函数性能，记录执行时间
4. session校验

中间件可以定义方法：
def process_request(self, request):
def process_view(self, request, callback, callback_args, callback_kwargs):
def process_exception(request, exception)
def process_template_response(request, response)
def process_response(self, request, response):
详情参考：https://docs.djangoproject.com/en/2.2/topics/http/middleware/

请求在中间件中执行流程：
    0.中间件起点
            执行所有中间件的process_request function--> 
                    回到中间件起点 ---> 
                        执行 所有中间件process_view function---> 
                            执行路由&视图
                                从下到上依次执行所有中间件的process_exception function(程序有异常 才会执行)
                                    回到中间件最后面
                                        从下到上依次执行中间件process_response function

 

缓存目的:减少对数据库的操作（针对数据不经常变化，第一次请求完成后将数据放入缓存，后续有新请求进来直接从缓存拿数据，没必要重复操作数据库）。

Django默认支持缓存，使用自带缓存前需要进行配置。
Django支持的缓存有6种方式：
1.开发调试，不在任何地方存储
2.内存
3.文件 
4.数据库
5.memcache(依赖python-memcache模块) 
6.memcache(依赖pylibmc模块)

Django缓存配置：
在setting文件中添加如下代码：
CACHES = {
            'default': {
                'BACKEND': 'django.core.cache.backends.dummy.DummyCache',     # 引擎
                'TIMEOUT': 300,                                               # 缓存超时时间（默认300，None表示永不过期，0表示立即过期）
                'OPTIONS':{
                    'MAX_ENTRIES': 300,                                       # 最大缓存个数（默认300）
                    'CULL_FREQUENCY': 3,                                      # 缓存到达最大个数之后，剔除缓存个数的比例，即：1/CULL_FREQUENCY（默认3）
                },
                'KEY_PREFIX': '',                                             # 缓存key的前缀（默认空）
                'VERSION': 1,                                                 # 缓存key的版本（默认1）
                'KEY_FUNCTION' 函数名                                          # 生成key的函数（默认函数会生成为：【前缀:版本:key】）
            }
        }

实际在使用过程中，根据使用的缓存策略不同， 替换对应的引擎即可。
Memcache引擎：
# using the python-memcached binding:
'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': '127.0.0.1:11211',
    }

# using the python-memcached binding:
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': 'unix:/tmp/memcached.sock',
    }
}

#using the pylibmc binding
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyLibMCCache',
        'LOCATION': '/tmp/memcached.sock',
    }
}

#Memcached instances running on IP address 172.19.26.240 and 172.19.26.242, both on port 11211:
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.MemcachedCache',
        'LOCATION': [
            '172.19.26.240:11211',
            '172.19.26.242:11211',
        ]
    }
}

#DB引擎
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',
        'LOCATION': 'my_cache_table',
    }
}

#Before using the database cache, you must create the cache table with this command:
python manage.py createcachetable

#文件引擎
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',
        'LOCATION': 'c:/foo/bar',
    }
}

#内存引擎
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'unique-snowflake',
    }
}


Django支持缓策略：
1.单个视图缓存---> 装饰器 
2.局部缓存 
3.全站缓存--->需要依赖中间件

a. 单个视图缓存
方式1：
from django.views.decorators.cache import cache_page

        @cache_page(300) #参数指 超时时间
        def home_view(request):
            ...
方式2:
from django.views.decorators.cache import cache_page
from business import views as busin_views
urlpatterns = [
    path('home/', cache_page(300)(busin_views.home)),
]

b.局部视图缓存
1.在模板最开始引入Templatetag
 {% load cache %}

2.使用缓存
{% cache 300 cache_key %}  # cache_key可以自定义
            想要缓存内容
{% endcache %}

c.全栈缓存
在中间件的开始和结束的地方各加一个中间件。
有请求进来之后，经过一系列中间件，如果内容在缓存中存在，则使用FetchFromCacheMiddleware获取内容并返回给用户。当返回给用户之前，判断缓存中是否已经存在，如果不存在则UpdateCacheMiddleware会将缓存保存至缓存，从而实现全站缓存
MIDDLEWARE = [
        'django.middleware.cache.UpdateCacheMiddleware',
        # 其他中间件...
        'django.middleware.cache.FetchFromCacheMiddleware',
    ]

****自定义缓存****；
1.使用中间件/装饰器自定义操作

详情见： https://docs.djangoproject.com/en/2.2/topics/cache/#cache-arguments

 

django信号作用：
0.通过ORM进行数据库操作前，如果想进行一些操作，可以使用信号
1.信号能批量做操作
2.django程序启动完成之后，注册的信号应该已经可以使用。
    即信号需要在程序运行前先加载完成；所以使用信号时，信号的相关代码建议写在同项目名同名下的__init__.py文件中

django内置信号：
一、Model signals：
1.django.db.models.signals.pre_init
2.django.db.models.signals.post_init
3.django.db.models.signals.pre_save
4.django.db.models.signals.post_save
5.django.db.models.signals.pre_delete
6.django.db.models.signals.post_delete
7.django.db.models.signals.m2m_changed
8.django.db.models.signals.class_prepared

二、Management signals
1.django.db.models.signals.pre_migrate
2.django.db.models.signals.post_migrate

三、Request/response signals
1.django.core.signals.request_started
2.django.core.signals.request_finished
3.django.core.signals.got_request_exception

四、Test signals
1.django.test.signals.setting_changed
2.django.test.signals.template_rendered

五、Database Wrappers
django.db.backends.signals.connection_created

详情见： https://docs.djangoproject.com/en/2.2/ref/signals/#module-django.db.backends


信号使用：
django.db.models.signals.pre_delete

def warn_pre_delete(sender, instance, using):
    '''
    代码
    '''
    pass    

pre_delete.connect(warn_pre_delete )

 

django models中的class Meta介绍
Meta中的元选项：
abstract：
    值为True时，对应的model不会在数据库中创建表，
    如果model被继承，则model中的field会添加到子类中

app_label:
    app没有在INSTALLED_APPS,注册的时候， model中需要指定当前model属于哪个app
    
db_table:
    修改model在数据库中的表名，默认表名为appname_modelName(小写)

get_latest_by:
    值为model中的一个字段 或者 多个字段列表，常用字段类型：日期、数字
    设置之后 跟latest() and earliest() methods 配合使用

managed：
    默认为True，执行migrate命令时会创建数据库以及执行migrations命令会生成缓存
    设置为False后，执行migrate & migrations不会生效

order_with_respect_to：
    和外键一起使用，对外键可排序， 值为外键字段
    使用场景： 一对多
    For example, if an Answer relates to a Question object, and a question has more than one answer, and the order of answers matters(顺序很重要), you’d do this:
    
    from django.db import models
    class Question(models.Model):
        text = models.TextField()
        # ...

    class Answer(models.Model):
        question = models.ForeignKey(Question, on_delete=models.CASCADE)
        # ...

        class Meta:
            order_with_respect_to = 'question'
    
    上述设计之后关联了4个方法：
    get_RELATED_order()   # RELATED is the lowercased model name
    set_RELATED_order()
    get_next_in_order()
    get_previous_in_order()
    
    实战：
    >>> question = Question.objects.get(id=1)
    >>> question.get_answer_order()
    >>> question.set_answer_order([3, 1, 2])
    >>> answer = Answer.objects.get(id=2)
    >>> answer.get_next_in_order()
    >>> answer.get_previous_in_order()
    
ordering： 
    排序， 值是一个列表或者元组
    ordering = ['-order_date']  降序排列
    ordering = ['pub_date']  升序排列
    ordering = ['?pub_date']  随机排列
    ordering = ['-pub_date', 'author']  pub_date 降序排列, 然后 author 升序排序
    ordering = [F('author').asc(nulls_last=True)]

default_permissions：
    默认对model的权限，默认值 ('add', 'change', 'delete', 'view')
    可以自定制
    
indexes：
    设置索引
    from django.db import models

    class Customer(models.Model):
        first_name = models.CharField(max_length=100)
        last_name = models.CharField(max_length=100)

        class Meta:
            indexes = [
                models.Index(fields=['last_name', 'first_name']),
                models.Index(fields=['first_name'], name='first_name_idx'),
            ]

unique_together：
    设置联合唯一索引
    格式： unique_together = [['driver', 'restaurant']]  或者 unique_together = ['driver', 'restaurant']
    
index_together：
    设置索引，可以不唯一
    格式同unique_together
    后续会被indexes替换掉
    
constraints：
    2.2中的新功能
    在model中想定义的约束条件
    from django.db import models

    class Customer(models.Model):
        age = models.IntegerField()

        class Meta:
            constraints = [
                models.CheckConstraint(check=models.Q(age__gte=18), name='age_gte_18'),
            ]

verbose_name：
    django admin后台更可读的object 名字; 作用同verbose_name_plural，只不过verbose_name_plural优先级高一先。同时配置了verbose_name 和 verbose_name_plural之后， 显示的是verbose_name_plural的值
    
verbose_name_plural：
    django admin后台使用，登录首页展示的app的name;
    
    
详情参考 https://docs.djangoproject.com/en/2.2/ref/models/options/

 

 

QuerySet可以被：
    Iteration：迭代、
    Slicing：切片、
    len()：获取长度、
    list()：
    bool()：转化为list、判断是否为真
    repr(): 交互模式下，querySet调用repr()，将对其求值。可以立即看到结果
    Pickling/Caching: 做数据缓存

Methods that return new QuerySets：
filter() 
    #filter(**kwargs)
    # 返回一个新querySet包含与给定查找参数匹配的对象
exclude() 
    #exclude(**kwargs)
    # 排除...
annotate() 
    #annotate(*args, **kwargs)
order_by() 
    #order_by(*fields)
    # 默认按model class meta中指定排序，也可以手动输入需要排序字段
    Entry.objects.order_by(Lower('headline').desc())
    #asc() and desc() have arguments (nulls_first and nulls_last) that control how null values are sorted.
reverse() 
    # 将querySet的顺序倒排
distinct()： 
    #distinct(*fields)
    #去除重复数据，等同于sql： select distinct() from tb_table
values():
    #values(*fields, **expressions)
    方式1：
    from django.db.models.functions import Lower, Upper
    blogs = Blog.objects.values(lower_name=Lower('name'))
    方式2：
    from django.db.models import CharField
    from django.db.models.functions import Lower
    CharField.register_lookup(Lower)
    Blog.objects.values('name__lower')
values_list(): 
    #values_list(*fields, flat=False, named=False)
    #如果values_list中只有1个字段时，可以设置flat=True，返回值会是1个字段而非元组
    #如果values_list中有多个字段，可以设置named=True,返回值元组会有一个统一的name

dates():
    #dates(field, kind, order='ASC')
    #field必须是DateField类型
    #kind值[year、month、week、day]
    #order默认是ASC， 可以选择desc
    #返回值时一个datetime.date类型
    
datetimes()：
    #datetimes(field_name, kind, order='ASC', tzinfo=None)
    
none()：
    #返回值为空， 结果是EmptyQuerySet的对象
    #from django.db.models.query import EmptyQuerySet

all():

union():
    #union(*other_qs, all=False)
    #等同于SQL的 union， 默认只选择distinct值， 如果要允许重复值，设置all=True 
    #将两个querySet连接起来

difference():
    #difference(*other_qs)
    #取的是a中存在b不存在的数据
    #>>>qs1.difference(qs2, qs3)

select_related():
    #select_related(*fields)
    
prefetch_related()
    #prefetch_related(*lookups)
    
extra()
    extra(select=None, where=None, params=None, tables=None, order_by=None, select_params=None)
    避免django无法写出一个负责的where字句，所以提供了此方法
    #select 字段允许给查询字段设置别名， select的值需要是字典格式 eg： Entry.objects.extra(select={'is_recent': "pub_date > '2006-01-01'"})

defer():
    # 排除

only():
    #只取only设置的字段
    
using():
    using(alias)
    #数据库集群时使用

select_for_update()
    select_for_update(nowait=False, skip_locked=False, of=())
    
    
Methods that do not return QuerySets：
filter()
get(**kwargs)：
create()：
get_or_create()：
    obj, created = Person.objects.get_or_create(
    first_name='John',
    last_name='Lennon',
    defaults={'birthday': date(1940, 10, 9)},
    )#除了名为defaults的可选选项之外，任何关键字参数都将在get调用中使用
    
update_or_create(defaults=None, **kwargs)：
    查询到数据，则使用default进行更新
    obj, created = Person.objects.update_or_create(
    first_name='John', last_name='Lennon',
    defaults={'first_name': 'Bob'},
    )
    
bulk_create()：
    bulk_create(objs, batch_size=None, ignore_conflicts=False)
    批量操作
    方式1：
    Entry.objects.bulk_create([
...     Entry(headline='This is a test'),
...     Entry(headline='This is only a test'),
... ])
    
    方式2：
    from itertools import islice

    batch_size = 100
    objs = (Entry(headline='Test %s' % i) for i in range(1000))
    while True:
        batch = list(islice(objs, batch_size))
        if not batch:
            break
        Entry.objects.bulk_create(batch, batch_size)

count()：
    返回值时一个数字

latest()/earliest():
    基于给定字段返回表中最新对象

first()/last():
    第一条数据
    
aggregate(*args, **kwargs):
    Returns a dictionary of aggregate values (averages, sums, etc.) calculated over the QuerySet
    
exists():
update():
delete():
explain(): sql执行过程


字段查询：
exact、iexact
contains、icontains
in
gt\lt\gte\lte
startswith\istartswith
endswith\iendswith
range
date\year\iso_year\month\week\day\week_day\hour\minute\second
isnull
regex

Avg\Count\Max\Min\Sum

 

 

models:
class Blog(models.Model):
    name = models.CharField(max_length=30)
    tagline = models.TextField()

    def __str__(self):
        return self.name


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

    def __str__(self):
        return self.name


class Entry(models.Model):
    blog = models.ForeignKey(Blog, on_delete=models.CASCADE)
    headline = models.CharField(max_length=255)
    body_text = models.TextField()
    pub_date = models.DateField()
    mod_date = models.DateField()
    authors = models.ManyToManyField(Author)
    number_of_comments = models.IntegerField()
    number_of_pingbacks = models.IntegerField()
    rating = models.IntegerField()

    def __str__(self):
        return self.headline
F()说明：
# 比较同一个model中两个字段的value，可以使用F()
# F() objects 支持加法、减法、乘法、除法、模和幂运算
# F()支持按位运算 .bitand() .bitor() .bitrightshift().bitleftshift()
Entry.objects.filter(number_of_comments__gt=F('number_of_pingbacks')*2)


Q说明：
# filter\get\exclude中有多个关键字参数时，是以 and 形式进行查询，如果想执行更多的复杂查询（使用or查询），则需要用到Q， Q与~一起 表示 not
~Q(pub_date__year=2005)
# 如果一个查询操作使用了两个Q object，则会生成一个新的Q object
#Q objects can be combined using the & and | operators 翻译：Q可以联合&、| 操作
Q(question__startswith='Who') | Q(question__startswith='What')

#filter\get\exclude 中既使用了关键字参数，又使用了Q object， 则Q必须在关键字参数之前
Poll.objects.get(
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6)),
    question__startswith='Who',
)

#filter\get\exclude中有多个Q时，Q与Q之间也是and查询
Poll.objects.get(
    Q(question__startswith='Who'),
    Q(pub_date=date(2005, 5, 2)) | Q(pub_date=date(2005, 5, 6))
)

 

 

创建
方式1：models.UserInfo.objects.create(username='', password='') #创建 UserInfo为类名
方式2：obj=models.UserInfo(username="", password="")
obj.save()
方式三：dic = {'username': '', 'password':''}
models.UserInfo.objects.create(**dic)

查询
方式1：models.UserInfo.objects.all() #查询表中全部字段
方式2：models.UserInfo.objects.values(username, password) #查询表中指定字段
方式3：models.UserInfo.objects.values_list(username, password) #查询表中指定字段
方式4：models.UserInfo.objects.filter(id=1)
方式4：models.UserInfo.objects.filter(username='admin', password='root')
方式4：models.UserInfo.objects.filter(id_gt=1) # 查询id>1 的数据
方式4：models.UserInfo.objects.filter(id_lt=1) # 查询id<1 的数据
方式5：models.UserInfo.objects.get(id=1) #只获取一条，，如果id不存在，程序报错
方式6：models.UserInfo.objects.all().order_by('-id') #按照id倒叙排列
方式7：models.UserInfo.objects.all().select_related('foreign_key') #查询自己&关联外键表的数据（使用left join 跨表查询）
方式7：models.UserInfo.objects.all().select_related('foreign_key'， 'second_foreign_key') #查询自己&关联外键表的数据（使用left join 跨表查询）
方式8：models.UserInfo.objects.all().prefetch_related('foreign_key','second_foreign_key','....') #跨表查询会耗时，解决不想跨表&不想多次查询，会发2次单表sql请求
执行流程解析：
models.UserInfo.objects.all()
models.Part.objects.filter(id__in=[1,2,3,4]) #1,2,3,4表示上一条sql中的全部ID

删除
models.UserInfo.objects.all().delete() #删除全部数据
models.UserInfo.objects.filter(id=1).delete() #删除全部数据
更新
models.UserInfo.objects.all().update(password=99999)
models.UserInfo.objects.filter(id=1).update(password=99999)

补充：

性能相关查询：
0.select_related() #obj=models.UserInfo.objects.all().select_related('part', 'tb_name', ...) , 数据库中只查询一次
obj=models.UserInfo.objects.all()
for item in obj:
print(item.name, item.password, item.part_id, item.part.title) #每一个item.part.title都会进行一次数据库查询

1.prefetch_related() #解决性能问题
#obj=models.UserInfo.objects.all().prefetch_related('part'，'tb_name', ...) , 数据库中查询两次，每次都是单表查询

内部查询过程：
1.obj=models.UserInfo.objects.all()
2.obj=models.Part.objects.filter(id__in=)

其他：    
2.models.UserInfo.objects.all().only('id', 'name') # querySet内部是一个个对象， 查询id、name
3.models.UserInfo.objects.all().defer('name') # querySet内部是一个个对象，不查询name字段

 

多对多关系创建表
{

方法1.自定义第三章表【使用外键】，表的列数无限制
方法2.django帮助写第三章表，使用ManyToManyField字段，列限制只有3列；
多对多跟本身的两张表没有关系
m=models.ManyToManyField(to="UserInfo")

# 对第三章表进行CURD操作
obj=models.UserGroup.objects.filter(id=1).first()
obj.m.add(1) #增加
obj.m.add(1,2,3,4)
obj.m.add(*[1,2,3])

obj.m.remove(2)# 删除
obj.m.remove(2,3,4)
obj.m.remove(*[1,2])

obj.m.clear() # 清空

obj.m.set([1,]) #更新 即 update,但会删除原数据

q=obj.m.all() # 获取到UserInfo表中的全部数据，返回值是queryset[obj,obj,obj,obj]
q=obj.m.filter(id__gt/id__lt=2) # 注意：此时filter对象是UserInfo,filter中id指的是userinfo表中的id
q=obj.m.values()
q=obj.m.values_list()
}

 

Django uses request and response objects to pass state through the system.
翻译：django使用request、response对象 通过系统传递状态
When a page is requested, Django creates an HttpRequest object that contains metadata about the request. Then Django loads the appropriate view, passing the HttpRequest as the first argument to the view function.
翻译：当一个页面被请求时，django创建了一个包含请求元数据的HTTPRequest对象。然后django加载对应的视图并将创建的HTTPRequest对象作为第一个参数传递给视图函数

HTTPRequest来源： from django.http.request import HttpRequest

HTTPRequest构造方法：
    def __init__(self):
        # WARNING: The `WSGIRequest` subclass doesn't call `super`.
        # Any variable assignment made here should also happen in
        # `WSGIRequest.__init__()`.

        self.GET = QueryDict(mutable=True)
        self.POST = QueryDict(mutable=True)
        self.COOKIES = {}
        self.META = {} #包含所有的http请求头
        self.FILES = MultiValueDict() #文件上传，只有请求方式为POST且form表单有属性enctype="multipart/form-data"时，才能获取值

        self.path = ''
        self.path_info = ''
        self.method = None
        self.resolver_match = None
        self.content_type = None
        self.content_params = None

HTTPRequest详解
HttpRequest.FILES：
FILES will only contain data if the request method was POST and the <form> that posted to the request had enctype="multipart/form-data". Otherwise, FILES will be a blank dictionary-like object.

HttpRequest.META：一个包含所有可用信息请求头的字典，可用信息依赖客户端&服务端，具体包括：
CONTENT_LENGTH – The length of the request body (as a string).
CONTENT_TYPE – The MIME type of the request body.
HTTP_ACCEPT – Acceptable content types for the response.
HTTP_ACCEPT_ENCODING – Acceptable encodings for the response.
HTTP_ACCEPT_LANGUAGE – Acceptable languages for the response.
HTTP_HOST – The HTTP Host header sent by the client.
HTTP_REFERER – The referring page, if any.
HTTP_USER_AGENT – The client’s user-agent string.
QUERY_STRING – The query string, as a single (unparsed) string.
REMOTE_ADDR – The IP address of the client.
REMOTE_HOST – The hostname of the client.
REMOTE_USER – The user authenticated by the Web server, if any.
REQUEST_METHOD – A string such as "GET" or "POST".
SERVER_NAME – The hostname of the server.
SERVER_PORT – The port of the server (as a string).

HTTPRequest的属性方法：
headers
scheme
encoding
upload_handlers
body

HTTPRequest的普通方法：
get_host
get_port
get_full_path
get_full_path_info
get_signed_cookie
get_raw_uri
build_absolute_uri
parse_file_upload
close
read
readline
readlines
is_secure
is_ajax

详情参考： https://docs.djangoproject.com/en/2.2/ref/request-response/

 

django response
source: from django.http import HttpResponse

HTTPResponse构造方法：
HttpResponse.__init__(content=b'', content_type=None, status=200, reason=None, charset=None)
    content：可迭代对象，通常是bytestring/string。其他类型会被转换成bytestring
    content_type: MIMIE type，没设置则取默认值，默认值为：text/html; charset=utf-8
    status: 响应码， 可以使用Python's http.HTTPStatus  
    reason: http响应短语，没有提供，则使用默认短语
    charset：response使用的编码，如果没有设置，则从content_type提取，如果提取失败/不可用，则使用DEFAULT_CHARSET(utf-8)

HTTPResponse返回值：
1.返回字符串
from django.http import HttpResponse
>>> response = HttpResponse("Here's the text of the Web page.")
>>> response = HttpResponse("Text only, please.", content_type="text/plain")
>>> response = HttpResponse(b'Bytestrings are also accepted.')

2.以增量方式返回字符串
>>> response = HttpResponse('..........')
>>> response.write("<p>Here's the text of the Web page.</p>")
>>> response.write("<p>Here's another paragraph.</p>")

3.返回可迭代对象

4.设置response-header
>>> response = HttpResponse()
>>> response['Age'] = 120

5.告诉浏览器把response作为一个文件附件
>>> response = HttpResponse(my_data, content_type='application/vnd.ms-excel')
>>> response['Content-Disposition'] = 'attachment; filename="foo.xls"'


HTTPResponse普通方法：
HttpResponse.has_header(header)
HttpResponse.setdefault(header, value)
HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)
HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False, samesite=None)
HttpResponse.delete_cookie(key, path='/', domain=None)
HttpResponse.close()
HttpResponse.write(content)
HttpResponse.flush()
HttpResponse.tell()
HttpResponse.getvalue()
HttpResponse.readable()
HttpResponse.seekable()
HttpResponse.writable()
HttpResponse.writelines(lines)


自定义response类：
from http import HTTPStatus
from django.http import HttpResponse

class HttpResponseNoContent(HttpResponse):
    status_code = HTTPStatus.NO_CONTENT

 

django自定义simple_tag/filter步骤:

1.app在INSTALLED_APPS中注册
2.app下创建一个 templatetags  Python package
3.templatetags下创建一个python file, file name不能与其他应用程序中自定义tags/filters冲突
    app01/
        __init__.py
        models.py
        templatetags/
            __init__.py
            poll_extras.py
        views.py
4.在python file中必须有一个template.Library的实例且变量名为register 
    from django import template
    register = template.Library()
5. 模板中导入格式：
{% load poll_extras %}


一、自定义template filters
django.template.Library.filter()
1.filter定义
2.注册filter register.filter('lower', lower)

自定义template filters就是一个包含一个或两个参数的python function
The value of the variable (input) – not necessarily a string.
The value of the argument – this can have a default value, or be left out altogether.
    filter定义：
    def cut(value, arg):
        """Removes all values of arg from the given string"""
        return value.replace(arg, '')
    eg： {{ var|foo:"bar" }}  
    

filter注册需要传递2个参数：
1.The name of the filter – a string.
2.The compilation function – a Python function (not the name of the function as a string).
    filter注册：
    register.filter('cut', cut)

也可以将register.filter()作为一个装饰器
@register.filter(name='cut')
def cut(value, arg):
    return value.replace(arg, '')

@register.filter     #如果没有指定name, django默认使用函数名代替
def lower(value):
    return value.lower()
    
register.filter()也可以传递关键字参数： is_safe, needs_autoescape, and expects_localtime

建议写法:
from django import template
from django.template.defaultfilters import stringfilter
register = template.Library()

@register.filter
@stringfilter   #  传递参数为数字时，不会报AttributeError异常
def lower(value):
    return value.lower()
    
模板中filter调用格式：
{{ first_param|custom_filter second_param }}


二、自定义template tags 
tags比filter复杂，因为tags可以做任何事情。
django.template.Library.simple_tag()

1. simple_tag 函数可以接受任意数量的位置、关键字参数
@register.simple_tag
def my_tag(a, b, *args, **kwargs):
    warning = kwargs['warning']
    profile = kwargs['profile']
    ...
    return ...
    
2. 修改tag名字
register.simple_tag(lambda x: x - 1, name='minusone')

@register.simple_tag(name='minustwo')
def some_function(value):
    return value - 2
    
3.模板中使用tags
{% custom_tag params %} 或者 {% custom_tag params as result%}  {{result}}

注意：tags 可以和 filter一起使用。{% my_tag 123 "HelloWorld" warning="MESSAGE"|lower profile=user.profile %}  #lower为上面定义的filter



三、inclusion tags 
django.template.Library.inclusion_tag()
另外一种常用模板标签是通过render另外一个模板展示一些数据。比如：django admin后台使用自定义tag沿着'add/change'底部展示按钮




参考： https://docs.djangoproject.com/en/2.2/howto/custom-template-tags/