程序猿的冒险谭
程序猿的冒险谭

django框架学习

一个简单的web框架;

后端：

import socket
server=socket.socket()
server.bind(("127.0.0.1",8080))
server.listen()
while True:
    conn,addr=server.accept()
    data=conn.recv(1024)
    #对字符进行处理
    data=data.decode("utf-8")
    #获取网址后缀名
    conn.send(b"HTTP/1.1 200 ok\r\n\r\n")
    current_path=data.split("")[1]
    if current_path=='/index':
        conn.send(b"byebye")
    #忽略favicon.ico文件
    conn.send(b"hello")  #加入http相关的头
    conn.close()

django框架学习_第1张图片
加入/index后：
django框架学习_第2张图片

wsgiref模块

后端：

from wsgiref.simple_server import make_server
def run(env,response):
    #相关参数作用
    #param env:请求相关的所有数据  #大字典里面有各式各样的数据 wsgiref模块帮你处理好http格式的数据
    #param response：响应相关的所有数据
    #return ：返回给浏览器的数据
    #从env中获取后缀
    response("200 ok", [])  # 响应收行，响应头  括号内加入字典
    current_path=env.get("PATH_INFO")
    if current_path=='/index':
        return [b'index']
    #路径不存在返回404错误
    return [b'404error']
if __name__ == '__main__':
    server=make_server('127.0.0.1',8080,run)
    #会实时监听127.0。0.1：8080地址，只要有客户端来了都会交给run函数运行
    #flask启动源码 后面加类

    server.serve_forever()   #启动服务端

打印的env字典数据：
在这里插入图片描述

404报错：
django框架学习_第3张图片
注意一些专业称呼：

url.py               路由与视图函数对应关系
views.py             视图函数（后端业务逻辑）
templates            专门用来储存html文件

动静态网页

动态网页：
页面上的数据是直接写死的 万年不变
动态网页：
数据实时获取
eg：
1·后端获取当前时间展示到html页面上
2·数据是从数据库中获得的展示在html页面上
动态网页制作

from wsgiref.simple_server import make_server
import datetime
def run(env,response):
    #相关参数作用
    #param env:请求相关的所有数据  #大字典里面有各式各样的数据 wsgiref模块帮你处理好http格式的数据
    #param response：响应相关的所有数据
    #return ：返回给浏览器的数据
    #从env中获取后缀
    response("200 ok", [])  # 响应收行，响应头  括号内加入字典
    print(env)
    current_path=env.get("PATH_INFO")
    if current_path=='/index':
        with open(r"一个html文件.html","r",encoding="utf-8") as f:
            file=f.read()
        file=file.replace("这一步在html页面上设个flag然后替换即可", str(datetime.datetime.now()))
        return [file.encode('utf-8')]
    #路径不存在返回404错误
    return [b'404error']
if __name__ == '__main__':
    server=make_server('127.0.0.1',8080,run)
    #会实时监听127.0。0.1：8080地址，只要有客户端来了都会交给run函数运行
    #flask启动源码 后面加类

    server.serve_forever()   #启动服务端

html页面中传入字典

from jinja2 import Template
tmp=Template(data)  #data是文件.read()后的值
res=tmp.render(user=user_dic)

页面拿值同上replace方法

{{ user }}

python三大主流web框架：

django:
特点: 大而全, 自带的功能特别特别特别的多, 类似于航空母舰
	不足之处: 有时候过于笨重
flask:
特点: 小而精, 自带的功能特别特别特别的少, 类似于游骑兵
	第三方的模块特别特别特别的多, 如果将flask第三方的模块加起来完全可以盖过django,并且也越来越像django
	不足之处: 比较依赖于第三方的开发者
tornado：
特点:异步非阻塞, 支持高并发
		牛逼到甚至可以开发游戏服务器
#####################################################
A : socket部分	B: 路由与视图函数对应关系(路由匹配)	C: 模版语法
django	别人的, wsgiref模块	自己写	自己的(没有jinja2好用 但是也很方便)
flask	别人的 werkzeug(内部还是wsgiref模块)	自己写	别人的(jinja2)
tornado	自己写	自己写	自己写

django安装：

pip install django==1.11.11
#如果装了其他版本无需卸载直接装即可

#django项目启动
命令行版：

#创建django项目
#可以先cd到一个盘然后再创建
django-admin startproject 项目名

mysite文件夹
——mange.py
——mysite文件夹
————setting.py
————urls.py
————wsgi.py
#启动django项目
一定要先切换到项目目录下
python3 mange.py runserver
#3.创建应用：
django是一款专门用来开发app的web框架
python manage.py startapp app名字
#创建应用一定要在配置文件中注册

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app02',
    #或者
   #'app02.apps.App02Config'
]

#1.命令行创建不会自动有templatew文件夹 需要你自己手动配置创建而pycharm会自动帮你创建
#并且还会自动在配置文件中帮你配置路径
pycharm创建：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

命令行创建的：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': []
        #命令行创建的django项目的时候不单单需要创建templates文件夹还需要去配置文件中的路径
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

主要文件介绍

-mysite项目文件夹
–mysite文件夹
—setting.py 配置文件
—urls .py 路由与视图函数对应关系
—wsgi.py wsgiref模块
–mange .py django的入口文件
–db.sqlite3 django自带的sqlite3数据库（小型数据库 功能少 bug）
–app01文件夹
—admin.py django后台管理
—apps.py 注册使用
—migrations 数据库迁移记录
—models .py 数据库相关的 模型类
—test .py 测试文件
—views.py 视图函数
setting详细：

"""
Django settings for untitled10 project.

Generated by 'django-admin startproject' using Django 1.11.11.

For more information on this file, see
https://docs.djangoproject.com/en/1.11/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
"""

import os

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))


# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'k-emmcy4-0(zf14&vz)hplvv3+xff)w&j(*)w*!oo)3^w+(4$j'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True               #上线后改为flase 就是打印很多信息

ALLOWED_HOSTS = []  #允许访问的主机 用*代表全部


# Application definition
#注册的app （app就是功能模块）
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    #'app02',
    #或者
   'app02.apps.App02Config',
]
#django中间件
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

ROOT_URLCONF = 'untitled10.urls'
#html文件路径配置
TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')]
        ,
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

WSGI_APPLICATION = 'untitled10.wsgi.application'

#数据库 默认sqlite3
# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}


# Password validation
# https://docs.djangoproject.com/en/1.11/ref/settings/#auth-password-validators

AUTH_PASSWORD_VALIDATORS = [
    {
        'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
    },
    {
        'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
    },
]


# Internationalization
# https://docs.djangoproject.com/en/1.11/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True


# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.11/howto/static-files/

STATIC_URL = '/static/'

静态文件配置

在templates的同级文件夹下创建一个static文件
#静态文件夹
前端已经写好了 能够直接调用使用的文件
网站写好的js文件
网站写好的css文件
网站用到的图片文件
第三方前端框架
在setting中的操作：

#STATIC_URL就是页面导入令牌
STATIC_URL = '/static/'
#/static/为一个令牌取列表中的路径依次向下查找
#静态文件配置
STATICFILES_DIRS=[
    os.path.join(BASE_DIR,"static"),
    #注意这个是从这几个文件夹中找
]

#当你在写django项目的时候 可能会出现后端代码修改但是前端页面没有变化的情况
1.同时在run两个django项目
2.浏览器缓存问题
静态文件的动态解析static_url

{% load static %}     #类似于导模块
<a href="{ % static'加入导入静态模块的路径' % }">a>

form表单action参数
1.不写 默认朝当前所在的url提交数据
2.全写
3.只写后缀

提交表单的时候会遇见这个问题：
django框架学习_第4张图片
解决：
###在前期我们使用django提交post请求的时候 需要取配置文件中注释掉一行代码

#django中间件
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    #'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

request方法初识

request.method

返回method的类型：post或get
#返回请求的方式 并且是全大写的字符串

from django.shortcuts import render,HttpResponse

# Create your views here.
def login(request):
    #返回登录界面
    #get请求和post请求应该有不同的处理机制
    #：param request:
    #:return:
    print(request.method)
    #返回请求的方式 并且是全大写的字符串
    if request.method=="POST":
        return render(request,"debug_login.html")
    return render(request,'login.html')

#这里的login.html和debug_login.html借用了河南某211高校的打卡界面进行分析
获取用户数据

request.post

django框架学习_第5张图片
输入用户名和密码：
返回以下字典
在这里插入图片描述
返回一个字典（字典里面是一个列表形式的字符串）：
#且只能返回列表元素的最后一个
检验代码：

uid=request.POST.get("uid")   #获取uid
        print(type(uid))              #打印uid发现形式为列表形式的字符串
        upw=request.POST.get("upw")   #获取upw

检验结果：
在这里插入图片描述
获得列表的方法

request.POST.getlist

代码：

from django.shortcuts import render,HttpResponse

# Create your views here.
def login(request):
    #返回登录界面
    #get请求和post请求应该有不同的处理机制
    #：param request:
    #:return:
    print(request.method)
    #返回请求的方式 并且是全大写的字符串
    if request.method=="POST":
        print(request.POST)  # 获取用户提交的post请求
        #uid=request.POST.get("uid")   #获取uid
        uid=request.POST.getlist("uid")     #获取uid对应的列表（get方法只能获得字符串类型的uid数据）
        print(type(uid))              #打印uid发现形式为列表形式的字符串
        #upw=request.POST.get("upw")   #获取upw
        upw=request.POST.getlist("upw")
        return render(request,"debug_login.html")
    return render(request, 'login.html')

获得get方法返回的值
get方法返回的和post方法一样
如下：

request.GET
request.GET.get            #获取的数据同post
request.GET.getlist        #获取的数据同post

注意：get方法获取的数据较小只有4kb左右
而post方法没有限制
pycahrm使用mysql
pycharm的右侧有一个：django框架学习_第6张图片
pycharm支持的数据库：
django框架学习_第7张图片
安装对应的驱动：
django框架学习_第8张图片
在navicat中创建表和填入数据：
django框架学习_第9张图片
在pycharm中添加连接即可

django连接数据库

#django默认连接sqkite3
1.第一步配置文件修改：

# DATABASES = {
#     'default': {
#         'ENGINE': 'django.db.backends.sqlite3',
#         'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
#     }
# }
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': "username",
        'USER':"root",
        "HOST":"127.0.0.1",
        "PORT":3306,
        "PASSWORD":"*************",
        "CHARSET":"UTF8",
    }
}

2.代码声明：
django默认用的是mysqldb模块连接mysql
但是mysqldb模块兼容型差 需要手动改为mysql模块
#在项目名中的init.py或者任意的应用名下的init文件中书写以下代码：
（这个我的项目启动时候没有报错可能是因为我已经按照的mysqldb）

import pymysql
pymysql.install_as_MySQLdb()

DJANGO ORM
orm，对象关系映射
作用：能够让一个不会mysql的人通过python 面向对象的代码简单快捷的操作数据库：
不足之处：有时候sql语句效率偏低 需要你自己写sql语句
应用models.py文件

from django.db import models

# Create your models here.
class User(models.Model):
    #等价于id int primary_key auto_increment
    id =models.AutoField(primary_key=True)
    #username varchar(32)
    #charfield必须指定max_length 不然会报错
    #verbose_name该参数是所以字段都有的 就是用来对字段的解释
    username = models.CharField(max_length=32)
    #password int
    password= models.IntegerField()

###########数据库迁移命令#################

#linux系统上用（windows系统把python3换成python即可）
python3 manage.py makemigrations #将操作记录转移到migrations文件夹
python3 manage.py migrate   #将操作真正的同步到数据库中

在python3 manage.py migrate命令后的结果
django框架学习_第10张图片
python3 manage.py makemigrations命令运行的结果：
在这里插入图片描述
#只要你修改了model.py中跟数据库相关的代码 就必须重新执行上述两条命令
注意：

class Author(models.Model):
    #由于一张表中必须有一个主建字段 并且一般就叫id
    #所以当你不定义主键字段时候 orm会自动帮你创建一个名为id的字段
    username =models.CharField(max_length=32)
    password =models.IntegerField()

执行上述代码备份文件结果
django框架学习_第11张图片

字段的增删改查

字段的增加：
1.可以直接在终端给出默认值
2.该字段可以为空
3.直接设置默认值

inf=models.CharField(max_length=32,verbose_name="students inf",null=True,default='study')

#字段的增加过程中如果遇到问题：

django.db.utils.InternalError: (1050, "Table 'tb_books' already exists")

字段的修改：
直接修改即可 然后执行两条数据库迁移命令
字段删除：
直接修改即可 然后执行两条数据库迁移命令

数据的增删改查

查

#这个语句等价于select * from Users where name="";
##这个语句可以加入多个参数 默认用and连接多参
 res=models.Users.objects.filter(userlist=uid)

#在userlist表中查询uid的值 返回值是列表套数据的格式
它也支持索引取值 切片取值 但是不支持负数索引
它也不推荐用索引的方法取值
可以用

.first() # 取列表里面第一个值
 res=models.Users.objects.filter(userlist=uid).first()

一个简单的登录功能的实现

 if res:
            if upw==res.password:
              return HttpResponse("登录成功")
            else:
                return HttpResponse("密码错误")
        else:    
            return render(request,"debug_login.html")

数据的增删改查

数据的增加
第一种方法：

 res=models.userlist.objects.create(username=username,password=password)

#返回的是当前被创建对象的本身
#对数据库进行增加
具体代码：

def reg(request):
    #给用户返回一个注册界面
    if request.method=='POST':
    #获得uid所对应的input标签返回的post请求
        username=request.POST.get("uid")
        password=request.POST.get("upw")
#将请求返回数据库        res=models.userlist.objects.create(username=username,password=password)
        print(res)
    return render(request,"reg.html")

res打印的结果：
在这里插入图片描述
第二种方法：
#利用类的方法实例化对象

  #利用类的方法实例化对象
        res=models.userlist(username=username,password=password)
        #进行保存
        res.save()

数据的查询
查询所有数据：

   data=models.userlist.objects.filter()
   #或者
   data=models.userlist.objects.all()

具体代码：

def userlist(request):
    #查询出用户表里面所有的数据
    data=models.userlist.objects.filter()
    print(data)
    return HttpResponse(data)

运行结果：
django框架学习_第12张图片
在这里插入图片描述
当用render（）返回登录页面时：

def userlist(request):
    #查询出用户表里面所有的数据
    data=models.userlist.objects.filter()
    print(data)
    #local()就是把这个函数所返回的数据全部导入render（）函数中
    return render(request,'userlist.html',locals())

后端用for循环展示对象并且用{{user_obj.id}}方法 来获得后端返回的值
前端代码：


<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>$Title$title>
head>
<body>
{{ data }}
<h1 class="text-center">数据展示h1>
<div class="container">
    <div class="row1">
        <div class="collapse-toggle">
            <table>
                <thead>
                <tr>
                    <th>IDth>
                    <th>usernameth>
                    <th>passwordth>
                    <th>actionth>
                tr>
                thead>
                <tbody>
                    {% for user_obj in data %}
                        <tr>
                        <td>{{ user_obj.id }}td>
                        <td>{{ user_obj.username}}td>
                            <td>{{ user_obj.password }}td>
                        <td>
                            <a href="/edit_user/?user_id={{ user_obj.id }}">编 辑a>
                            <a href="">删 除a>
                        td>
                        tr>
                    {% endfor %}
                tbody>
            table>
        div>
    div>
div>
body>
html>

for循环处理数据：

 {% for user_obj in data %}
                        <tr>
                        <td>{{ user_obj.id }}td>
                        <td>{{ user_obj.username}}td>
                            <td>{{ user_obj.password }}td>
                        <td>
                            <a href="/edit_user/?user_id={{ user_obj.id }}">编 辑a>
                            <a href="">删 除a>
                        td>
                        tr>
                    {% endfor %}

结果：
django框架学习_第13张图片
数据的修改
#如何将修改那一行的主键值返回给后端？
前端：

 <a href="/edit_user/?user_id={{ user_obj.id }}">编 辑a>

#“？”后面的数据在网页中不匹配 可以用来返回主键
后端：

 #获取url问号后面的参数
    edit_id=request.GET.get("user_id")

#修改数据的两个方法：
#用filter筛选出来所有id=edit_id的数据进行批量更新

 models.userlist.objects.filter(id=edit_id).update(username=username,password=password)

#使用edit_obj返回一个类然后在对数据进行处理
#但字段特别多的时候效率比较低（从头到尾全部修改一下 无论字段是否被修改）

 #修改数据方法二
        edit_obj=models.userlist.objects.filter(id=edit_id).first()
        edit_obj.username=username
        edit_obj.password=password
        edit_obj.save()

一个简单的编辑页面的代码：
后端：

def edit_user(request):
    # 获取url问号后面的参数
    edit_id = request.GET.get("user_id")
    if request.method=="POST":
        #获取数据库中的应用
        username = request.POST.get("username")
        password = request.POST.get("password")
        print(username,password)
        #取数据库中修改对应的数据
        #修改数据方式一
        models.userlist.objects.filter(id=edit_id).update(username=username,password=password)
        #用filter筛选出来所有id=edit_id的数据进行批量更新
        #返回数据展示页面
        return redirect('/userlist/')
    #查询当前数据想要编辑的数据
    edit_obj=models.userlist.objects.filter(id=edit_id).first()
    #将数据展示到页面上
    return render(request,"edit_userlist.html",locals())

前端：


<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>$Title$title>
head>
<body>
{{ data }}
<h1 class="text-center">数据展示h1>
<div class="container">
    <div class="row1">
        <div class="collapse-toggle">
            <table>
                <thead>
                <tr>
                    <th>IDth>
                    <th>usernameth>
                    <th>passwordth>
                    <th>actionth>
                tr>
                thead>
                <tbody>
                    {% for user_obj in data %}
                        <tr>
                        <td>{{ user_obj.id }}td>
                        <td>{{ user_obj.username}}td>
                            <td>{{ user_obj.password }}td>
                        <td>
                            <a href="/edit_user/?user_id={{ user_obj.id }}">编 辑a>
                            <a href="">删 除a>
                        td>
                        tr>
                    {% endfor %}
                tbody>
            table>
        div>
    div>
div>
body>
html>

数据的删除

 delete_obj.delete()

后端：

def delete_user(request):
    delete_id = request.GET.get("user_id")
    delete_obj = models.userlist.objects.filter(id=delete_id)
    #二次确认 学了ajxs之后在考虑
    #删除数据
    delete_obj.delete()
    return redirect('/userlist/')

#删除数据内部不是真正的删除 我们会把数据添加一个标识字段来表示数据是否被删除 如果被删除只是修改一下它的状态

django orm中如何创建表关系

#外键要建到查询频率较高的地方
一对一
一对多
多对多
一个很好的讲表关系的博客
API：
一对多关系：

publish=models.ForeighKey(to="Publish")
#创建的字段 会自动的在字段后面加上_id 如：publish_id
#默认以表的主键字段当外键关联

多对多关系：

authors = models.ManyToManyField(to="Author")
#authors是一个虚拟字段 主要是用来告诉orm 书籍表和作者表是多对多关系
#让orm自动帮你创建第三张表

一对一关系：

author_detail = models.OneToOneField(to = "AuthorDetail")
#创建的字段 会自动的在字段后面加上_id

class book(request):
	title = models.CharField(max_length=32)
	#小数总共八位 小数点后面占两位
	price = models.DecimalField(max_digits=8,decimal_places=2)
class Publish(request):
	name = models.CharField(max_length=32)
	addr = models.CharField(max_length=32)	
class Author(models.Model):
	phone = models.CharField(max_length=32)
	age = models.IntegerField()
	author_detail = models.OneToOneField(to = "AuthorDetail")
class AuthorDetail(models.Model):
	phone = models.BigIntegerField()
	addr = models.CharField(max_length=32)

#django1.x版本中外键默认都是级联更新删除的
#多对多的表关系还有很多的创建方式 这里是其中一种

django请求生命周期流程图

django框架学习_第14张图片
这里附上xmind的下载链接

#扩展知识点
缓存数据库：
提取已经将你想要的数据准备好了 你直接拿就可以了
提高效率和响应时间

路由匹配

urls.py：

  url(r'test',views_01.test),
   url(r'testadd',views_01.testadd)

views.py:

from django.shortcuts import render,HttpResponse

# Create your views here.
def test(request):
    return HttpResponse("test")
def testadd(request):
    return HttpResponse("testadd")

django框架学习_第15张图片
django框架学习_第16张图片
因为url方法的第一个参数是代表的是正则表达式，只要第一个参数正则能够匹配到内容 那么就会立刻停止往下匹配 所以，test所对的路由，和testadd所对应的路由是一样
#你在输入url的时候会默认加入斜杠
django内部帮你做到重定向
一次匹配不行
url后面加斜杠在来一次
取消这个功能的方法：
setting.py中加入这个参数

#取消自动加斜杠的功能
APP_SLASH=False

有时候匹配的时候在后面加入$号表示
严格以t开头以t结尾

 url(r'^test/$',views_01.test),
    url(r'^testadd/$',views_01.testadd)

匹配首页

url(r'^$',views.home)

匹配尾页：
#这行代码要加到最后一行

url(r'',views.error)

分组：

分组：给某一段正则表达式加入一个小括号进行分组
urls.py

无名分组：

 url(r'^test/(/d+)/',views_01.test),

views.py

def test(request,either):
	print(xx)
	return HttpResponse("test")

#无名分组就是将括号内的正则表达式的内容获取当成位置参数，传递给后面的视图函数
有名分组：
#可以给正则表达式起一个别名
#?P给括号内的正则表达式起一个别名year

 #有名匹配
    #?P给括号内的正则表达式起一个别名year
    url(r'^testadd/(?P\d+)',views_01.testadd),

views.py函数：

def testadd(request,year):
    print(year)
    return HttpResponse("testadd")

django框架学习_第17张图片
#有名参数就是将括号内的正则表达式匹配到的内容当作关键字参数传递给后面的视图函数
无名有名函数混用
#不能混用 但是同一个分组可以加多个有名分组 或者可以加多个无名分组（推荐使用有名分组）

反向解析：

#通过一些方法得到一个结果 该结果可以直接访问对应的url触发视图函数
1.先给路由和视图函数起一个别名
2.反向解析
#后端反向解析
#反向解析记得导入模块

from django.shortcuts import render,HttpResponse,reverse

views.py

reverse("func")

urls.py

   url(r"^func/$",views_01.func,name='func'),

#前端反向解析
home.html

<a href="{% url 'func' %}">111a>

urls.py

   url(r"^func/$",views_01.func,name='func'),

无名分组和有名分组的反向解析

无名分组反向解析：

url(r"^index/(\d+)/",views.index,name="index"),

#前端:这个123表示的是 他的args={1，2，3，}

{% url "index" 123 %}

#后端

reverse("index",args={1,})

#数字一般情况下放的是数据的主键值 数据的编辑和删除

url(r"^edit/(\d+)/",views.edit_id,name='edit')
def edit(request,edit):
	reverse("edit",args={edit,})
{{% for use_obj in user_queryset %}}
<a href="{{% url "edit" user_obj.id %}}
{{%endfor%}}

路由分发

django每一个应用都可以有自己的templates文件夹，urls.py ，static文件夹 正是基于上述特点，django能够非常好的做到分组开发（每个人只写自己的app）。
如果app中没有urls,py文件自己创建即可
一个基本的urls.py文件

"""untitled10 URL Configuration

The `urlpatterns` list routes URLs to views. For more information please see:
    https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
    1. Add an import:  from my_app import views
    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
Class-based views
    1. Add an import:  from other_app.views import Home
    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
Including another URLconf
    1. Import the include() function: from django.conf.urls import url, include
    2. Add a URL to urlpatterns:  url(r'^blog/', include('blog.urls'))
"""
from django.conf.urls import url

urlpatterns = [
]

#利用路由分发之后 总路由不在干路由与视图函数的直接对应关系而是做一个分发处理
#识别当前url是属于哪个应用下的 直接分发给对应的应用去处理

#给urls起别名的原因是防止多个app中的url出现重名
from app01 import urls as app01_urls
urlpatterns=[
#路由分发
#只要url前缀是app01开头的 全部交给app01处理
url(r'app01/',include(app01_urls))  
]

#或者可以不导模块
url(r"^app01/",include("app01.urls"))

名称空间

#当多个应用出现了相同的别名 我们研究反向解析会不会自动识别应用前缀
##正常情况下的反向解析是没有办法自动识别前缀的##

url(r"^app01/",include("app01.urls",namespace='app01'))

名称空间解析:
后端：

def reg(request):
	reverse("app01:reg")

前端：

{% url "app01:reg" %}

#一般情况下有多个app的时候 我们在起别名的时候会加上app的前缀
#这样一般情况下就能保证多个app之间名字不冲突

伪静态

将一个动态网页位置成静态网页
伪装的目的在于增大本网站的seo查询力度
并且增大搜索引擎收藏本网上的概率
搜索引擎本质就是一个巨大的爬虫程序
#无论你怎么优化怎么处理
还是不胜人家冲点钱
#伪静态实现直接在app01后面加上.html即可

url(r"^app01。html",include("app01.urls",namespace='app01'))

虚拟环境处理

虚拟环境就类似于python解释器环境
#每创建一个虚拟环境就类似于你重新下载一个python解释器#
#虚拟环境不要下载太多 很占磁盘环境#
#开发中我们会配置一个requirement.txt文件
里面书写了该项目所有的模块和版本
#直接输入

	
pip install -r requirements.txt

一个很好的博客
即可安装
虚拟环境创建

pip install virtualenv
virtualenv test #test为虚拟环境名字
#默认创建在本目录下 需要cd到该文件下运行该命令

django版本区别

路由层
1.X用的是url
2.X、3.X用的是path

url第一个参数是一个正则表达式
而path第一个参数不支持正则表达式 写什么就匹配什么
如果你觉得path不好用 2.x、3.x给你提供了一个跟url一样的功能
re_path 等价于1.x里面的url功能

虽然path不支持正则表达式 但是它给你提供了五种默认的转换器
str：匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
int：匹配正整数，包含0。
slug:匹配字母、数字以及横杠、下划线组成的字符串。
uuid:匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
path:匹配任何非空字符串，包含了路径分隔符（/）（不能用？）

path('login//',login)

除了默认的五种转换器之外 还支持你自定义转换器
自定义转换器
class MonthConverter:
regex=’\d{2}’ # 属性名必须为regex

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

def to_url(self, value):
return value # 匹配的regex是两个数字，返回的结果也必须是两个数字

django框架学习_第18张图片

#这里引用了一个博客
https://www.cnblogs.com/csic716/p/12158457.html

4.模型层里面1.x外键默认都是级联更新和删除的
但是在2.x和3.x中需要手动加参数

models.ForeignKey(on_delete=models.CASCADE,to="PUSH")

jsonresponse对象

这一段笔记电脑突然关机了QAQ
只剩下代码：

def ab_json(request):
    # import json
    from django.http import JsonResponse
    #user_dict={"username":"mzy你好","password":"123","hobby":"study"}
    # #先转化为json格式字符串
    # json_str=json.dumps(user_dict,ensure_ascii=False)
    # #f返回到前端
    # return HttpResponse(json_str)
    from django.http import JsonResponse
    user_dict = {"username": "mzy你好", "password": "123", "hobby": "study"}
    return JsonResponse(user_dict)

 return JsonResponse(user_dict,json_dumps_params={"ensure_ascii":False})

#结局乱码问题#

jsonresponse数据返回非json串数据

l=[111,222,333]
return JsonResponse(l,safe=False)

前端序列化：

JSON.stringify() json.dumps()

json.parse() json.loads()

from表单上传文件及后端的获取

from表单上传文件类型数据

1.method必须指定成post

2.enctype必须换成formdata

##获取数据时候不能使用request.POST方法应该使用request.FILES方法获取文件数据

保存文件的方法：

 with open(file_obj.name,"wb") as f:
            for line in file_obj:
                f.write(line)

总和代码：

##这里可以在templates文件夹里面建一个file_get文件夹然后with方法保存数据

def ab_file(request):
    if request.method=="POST":
        print(request.POST)   #request.POST只能获得普通的键值对的数据 文件不行
        print(request.FILES)  #获取文件数据
        file_obj=request.FILES.get("file")   #文件对象
        print(file_obj.name)                 #获取文件名字
        #保存文件
        path='C:/Users/mzy/Desktop/pycharmproject/untitled10/templates/file_get/'
        with open(path+file_obj.name,"wb") as f:
            for line in file_obj:
                f.write(line)
        print("end")
    return render(request,"ab_file.html")

django框架学习_第19张图片

request方法补充

request.method                                                  #获得请求类型
request.POST                                                   #获得post请求对象 不能获得文件
request.GET                                                     #获得get请求对象
request.FILES                                                   #获得post请求的文件
request.path                                                    #获取路由
request.path_inf                                                #获取路由
request.get_full_path()                                         #获取路由和后面完整参数
request.body                                                    #原生的浏览器发送的二进制数据

FBV和CBV

#视图函数可以是函数也可以是类

def index(request):
    return HttpResponse("index")

CBV

urls.py
url(r"^login_my/",views_03.Mylogin.as_view())
views.py
from django.views import View
class Mylogin(View):
    def get(self,request):
        return render(request,"ab_file.html")
    def post(self,request):
        return HttpResponse("Post")

CBV源码分析

#函数名/方法名 加括号表示执行优先级最高

urls.py

  url(r"^login/",views_04.Mylogin.as_view())

as_views()#是被@classonlymethod修饰的类方法：

源码：

    @classonlymethod
    def as_view(cls, **initkwargs):
        """
        Main entry point for a request-response process.
        """
        for key in initkwargs:
            if key in cls.http_method_names:
                raise TypeError("You tried to pass in the %s method name as a "
                                "keyword argument to %s(). Don't do that."
                                % (key, cls.__name__))
            if not hasattr(cls, key):
                raise TypeError("%s() received an invalid keyword %r. as_view "
                                "only accepts arguments that are already "
                                "attributes of the class." % (cls.__name__, key))

        def view(request, *args, **kwargs):
            self = cls(**initkwargs)   #cls是我们自己写的类
            #self = Mylogin(**initkwargs)  产生我们写的类对象
            if hasattr(self, 'get') and not hasattr(self, 'head'):
                self.head = self.get
            self.request = request
            self.args = args
            self.kwargs = kwargs
            return self.dispatch(request, *args, **kwargs)
        #以后会经常看源码 一定要时刻提醒自己面向对象属性方法查找顺序
        #先去对象自己找
        #再去产生对象的类里面找
        #之后在去父类找
        view.view_class = cls
        view.view_initkwargs = initkwargs

        # take name and docstring from class
        update_wrapper(view, cls, updated=())

        # and possible attributes set by decorators
        # like csrf_exempt from dispatch
        update_wrapper(view, cls.dispatch, assigned=())
        return view

#dispatch方法

 def dispatch(self, request, *args, **kwargs):
        # Try to dispatch to the right method; if a method doesn't exist,
        # defer to the error handler. Also defer to the error handler if the
        # request method isn't on the approved list.
        #获取当前请求的小写格式 然后比对当前请求是否合法
        if request.method.lower() in self.http_method_names:
            #八个默认的请求
# http_method_names = ['get', 'post', 'put', 'patch', 'delete', 'head','options','trace']

            handler = getattr(self, request.method.lower(), self.http_method_not_allowed)
    #反射：通过字符串来操作对象的属性或者方法
    #getattr(自己写的类产生的对象，“get”，当找不到get属性或者方法的时候就会用第三个参数)
        else:
            handler = self.http_method_not_allowed
        return handler(request, *args, **kwargs)
#自动调用get方法

因为这个方法是启动as_view函数并且返回view，且加括号表示执行优先级最高

#所以上述代码在启动django的时候就会立刻执行as_view方法

所以该代码等价于：url(r"^login/",views.view) 和FBV一样

#CBV和FBV在路由匹配上本质是一样的 都是路由 对应 函数内存地址

views.py

from django.shortcuts import render,HttpResponse
from django.views import View
# Create your views here.
class Mylogin(View):
    def get(self,request):
        return render(request,"login.html")
    def post(self,request):
        return HttpResponse("post")

模板语法的传值

locals()
locals 函数更新并以字典形式返回当前全部局部变量

  • 如果locals()出现在函数模块主体中,则会返回模块的默认局部变量
  • locals() 会返回直到函数本身位置的所有局部变量,local本行后面的变量不会被返回
  • 如果locals()只出现在模块中的某个函数定义中, 当声明此函数时,返回此函数中的局部变量与函数输入参数
return render(request,"index.html",{})      #{}内加入要返回的函数值

{{}}：变量相关

{%%}：逻辑相关

##传递函数名会自动加括号调用 但是模板语法不支持给函数传递额外的参数：{{ func }}

##函数中传递给前端的数是函数的返回值

##传递类名的时候也会自动加括号调用（实例化）

##内部会自动判读当前的变量名是否可以加括号调用 如果可以就会自动执行 针对的是函数名和类名

##对象展示到html页面上就类似于print，将结果展示在html

##django模板语法的取值 是固定的格式 只能采用“句点符”

##即可以点建也可以点索引 还可以两者混用

模板语法之过滤器

过滤器就相当于模板语法内置的内置方法

#django内置有六十个模板语法

#基本语法：

{{数据|过滤器:参数}}
#统计长度：
#后端：
s="mzy"
#前端：
{{s|length}}
内部方法：
@register.filter(is_safe=False)
def length(value):
    """Returns the length of the value - useful for lists."""
    try:
        return len(value)
    except (ValueError, TypeError):
        return 0
#默认值
#后端
b=False
#前端
{{ b|default:"mzy" }}
#类似于异常捕获 如果前面有值就用前面的 如果前面没值就采用default方法
#内部源码：
@register.filter(is_safe=False)
def default(value, arg):
    """If value is unavailable, use given default."""
    return value or arg
#文件大小：
#前端：
{{ file_size|filesizeformat }}
#内部源码：
    def filesize_number_format(value):
        return formats.number_format(round(value, 1), 1)

    KB = 1 << 10
    MB = 1 << 20
    GB = 1 << 30
    TB = 1 << 40
    PB = 1 << 50

    negative = bytes_ < 0
    if negative:
        bytes_ = -bytes_  # Allow formatting of negative numbers.

    if bytes_ < KB:
        value = ungettext("%(size)d byte", "%(size)d bytes", bytes_) % {'size': bytes_}
    elif bytes_ < MB:
        value = ugettext("%s KB") % filesize_number_format(bytes_ / KB)
    elif bytes_ < GB:
        value = ugettext("%s MB") % filesize_number_format(bytes_ / MB)
    elif bytes_ < TB:
        value = ugettext("%s GB") % filesize_number_format(bytes_ / GB)
    elif bytes_ < PB:
        value = ugettext("%s TB") % filesize_number_format(bytes_ / TB)
    else:
        value = ugettext("%s PB") % filesize_number_format(bytes_ / PB)

    if negative:
        value = "-%s" % value
    return avoid_wrapping(value)
#日期格式化
{s|date:"Y-m-d H:i:s"}
#默认是utc时间
#内部源码：
@register.filter(expects_localtime=True, is_safe=False)
def date(value, arg=None):
    """Formats a date according to the given format."""
    if value in (None, ''):
        return ''
    try:
        return formats.date_format(value, arg)
    except AttributeError:
        try:
            return format(value, arg)
        except AttributeError:
            return ''
#切片操作
{l|slice:"0:4:2"} #0代表起始位置  4代表末尾位置 2代表步长
#内部源码：
@register.filter("slice", is_safe=True)
def slice_filter(value, arg):
    """
    Returns a slice of the list.

    Uses the same syntax as Python's list slicing; see
    http://www.diveintopython3.net/native-datatypes.html#slicinglists
    for an introduction.
    """
    try:
        bits = []
        for x in arg.split(':'):
            if len(x) == 0:
                bits.append(None)
            else:
                bits.append(int(x))
        return value[slice(*bits)]

    except (ValueError, TypeError):
        return value  # Fail silently.

#切取字符（摘要）
{{ inf|truncatechars:9 }}
#这里九个字符包括摘要后面的三个点
#内部源码：
register.filter(is_safe=True)
@stringfilter
def truncatechars(value, arg):
    """
    Truncates a string after a certain number of characters.

    Argument: Number of characters to truncate after.
    """
    try:
        length = int(arg)
    except ValueError:  # Invalid literal for int().
        return value  # Fail silently.
    return Truncator(value).chars(length)
#切取单词
{{ l|truncatewords:9 }}
#这个切取是按照空格切取，且不包含后面三个点
#内部源码：
@register.filter(is_safe=True)
@stringfilter
def truncatewords(value, arg):
    """
    Truncates a string after a certain number of words.

    Argument: Number of words to truncate after.

    Newlines within the string are removed.
    """
    try:
        length = int(arg)
    except ValueError:  # Invalid literal for int().
        return value  # Fail silently.
    return Truncator(value).words(length, truncate=' ...')


#移除特定的字符
{{ msg|cut:"*" }}   #*代表要切除字符串里面的*
#内部源码：
@register.filter
@stringfilter
def cut(value, arg):
    """
    Removes all values of arg from the given string.
    """
    safe = isinstance(value, SafeData)
    value = value.replace(arg, '')
    if safe and arg != ';':
        return mark_safe(value)
    return value

#字符串拼接：
{{ l|join:"$" }}   #将列表以$拼接
#内部源码：
@register.filter(is_safe=True, needs_autoescape=True)
def join(value, arg, autoescape=True):
    """
    Joins a list with a string, like Python's ``str.join(list)``.
    """
    value = map(force_text, value)
    if autoescape:
        value = [conditional_escape(v) for v in value]
    try:
        data = conditional_escape(arg).join(value)
    except AttributeError:  # fail silently but nicely
        return value
    return mark_safe(data)

#拼接操作（加法）：
{{ n|add:s }}         #相当于“+”可以拼接字符串也可以数字相加
@register.filter(is_safe=False)
def add(value, arg):
    """Adds the arg to the value."""
    try:
        return int(value) + int(arg)
    except (ValueError, TypeError):
        try:
            return value + arg
        except Exception:
            return ''
#转义：
{{ h|safe }}              #这个可以让字符串型的标签在浏览器中进行转义（即以html形式在前端表示）
#内部源码：

@register.filter(is_safe=True)
@stringfilter
def safe(value):
    """
    Marks the value as a string that should not be auto-escaped.
    """
    return mark_safe(value)
#mark_safe函数：
def mark_safe(s):
    """
    Explicitly mark a string as safe for (HTML) output purposes. The returned
    object can be used everywhere a string or unicode object is appropriate.

    If used on a method as a decorator, mark the returned data as safe.

    Can be called multiple times on a single string.
    """
    if hasattr(s, '__html__'):
        return s
    if isinstance(s, bytes) or (isinstance(s, Promise) and s._delegate_bytes):
        return SafeBytes(s)
    if isinstance(s, (six.text_type, Promise)):
        return SafeText(s)
    if callable(s):
        return _safety_decorator(mark_safe, s)
    return SafeString(str(s))
#后端转义
#函数里面放入：
from django.utils.safestring import mark_safe
h="****"
res=mark_safe(h)
#在前端{{ h }}          #浏览器直接显示“*****”

###以后你在全栈项目开发的时候 前端代码不一定非要在前端页面书写
###也可以在后端写好 然后在传递给前端

模板语法之标签

#for循环：

#后端 
def index(request):
    #模板语法可以传递的后端python数据类型
    #{}里面可以加入想要返回后端的值但是local()方法也可以直接返回后端值
    line=[1,2,3,4,5,6]
    return render(request,"index.html",locals())
#前端{% for foo in line %}
<p>{{ forloop }}p>
{% endfor %}

#forloop简介：

#上述代码运行结果：

django框架学习_第20张图片

###用这个可以通过字典里的参数获得：位于for循环的正序（counter），倒序（recounter），第一个（first），最后一个（last），列表中的第几个（counter0）###

#if判断

{% if line %}
    <p>sssp>
    {% elif c%}
    <p>cccp>
{% else %}
    <p>bbbbp>
    
{% endif %}

##注意在for循环里面可以加if判断

{% for foo in line %}
    {{ forloop.first }}
    {% if forloop.first %}
        <p>这是第一次for循环,他的值为 {{ foo }}p>
        {% if forloop.last %}
        <p>这是最后一次for循环，他的值为{{ foo }}p>
        {% endif %}
        {% elif foo %}
        <p>这是第{{ forloop.counter }}次for循环，他的值为{{ foo }}p>
    {% endif %}
    {% empty %}
    <p>for循环是空的不能循环p>
{% endfor %}

django框架学习_第21张图片

#这个{ %empty% }表示的是for循环对象为空时，采用以下{% empty %}相当于default，

#这个模板语法很贴近python后端

#with

with：使用一个简单地名字缓存一个复杂的变量，当你需要使用一个“昂贵的”方法（比如访问数据库）很多次的时候是非常有用的

{% with total=business.employees.count %}
    {{ total }} employee{{ total|pluralize }}
{% endwith %}
<p>{{ person_list.2.name }}p>
{% with name=person_list.2.name %}
    <p>{{ name }}p>
{% endwith %}
 <#或者用更接近python语法的方法#>
     {% with totals as to %}
     {% endwith %}

自定义过滤器，标签，inclusion_tag

#在应用下创建一个名字叫templatetags文件夹

#在该文件夹下创建任意名字的py文件

#在py文件中必须引用两个话

from django import template
register=template.Library()
#自定义过滤器
@register.filter(name="my_add")
def my_add(v1,v2):
    try:
        if int(v1) and int(v2):
            return int(v1)+int(v2)
    except:
        #表示如果进行不了加和就返回0
        return 0

#前端：

{% load mytag %}
<p>{{ n|my_add:666 }}p>

##自定义过滤器就相当于最多只有两个参数的的函数##（后面如果传字典或者列表也可以（#更狠的可以加入字符串然后通过切割操作来进入多参））##

#自定义标签(可加多个参数)（就像自定义函数）

{#标签多个参数要用空格隔开#}
<P>{% plug "jason" 1 2 3  %}P>

#后端：

#自定义标签
@register.simple_tag(name="plug")
def index(a,b,c,d):
    return "%s-%s-%s-%s"%(a,b,c,d)

#自定义inclusion_tag

内部原理：
先定义一个方法

在页面上调用该方法 并且可以传值

该方法会生成一些数据然后传递给html页面

之后将渲染好的结果放到调用的位置

#后端：

#自定义inclusion_tag
@register.inclusion_tag("left.html")
def left(n):
    data=["第{}项".format(i) for i in range(n)]
    return locals()

#left.html页面

<ul>
    {% for foo in data %}
        <li>{{ foo }}li>
    {% endfor %}
ul>

#前端

{% load mytag %}
{#这是inclusiontags#}
{% left 10 %}

django框架学习_第22张图片

#总结：当html页面需要传参数才能动态的渲染出来，并且在多个页面上都需要使用到该局部 那么就考虑将该局面页面做成inclusiontags形式

模板的继承

#母版基本不变 只有母版中某个部分进行改变

母版

主要功能是给其它模板继承的

会为其它模板预留一些自定义的区块

{% block 块名 %}
{% endblock 块名 %}

子版

可以继承母版

同时往母版预留的区域中插入内容

往区域中插入内容

{% block 块名 %}
{% endblock 块名 %}

注意：

如果你在模版中使用 {% extends %} 标签，它必须是模版中的第一个标签。其他的任何情况下，模版继承都将无法工作。

#这是母版页面：

django框架学习_第23张图片

#这是子版页面：

django框架学习_第24张图片

#模板的继承 自己先选好一个想要继承的模板页面

#{% extends “home.html” %}

#继承了子页面跟模板页面长的一模一样 你需要在模板页面上提前划定可以被修改的区域

{% block 块名 %}

模板内容

{% endblock 块名 %}

#子页面就可以声明要修改哪一片划定的区域

{% block 块名 %}

子页面内容

{% endblock 块名 %}

#一般情况下，模板页面至少有三块可以被修改的区域

css区域

js区域

html区域

#这样可以使每一个子页面有不同的css

模块的导入

直接建立一个html文件

{% include "这个html文件" %}

#这样可以把这个html页面中所有代码导入该html

单表及测试环境操作准备

#django自带的sqlite3数据库对日期格式不是很敏感 处理时候容易出错

测试脚本：

当你只是想测试django中某一个py文件内容 那么你可以不用书写前后端的形式 而是直接写一个测试脚本即可

#测试环境配置

#在测试环境前加入这几行代码即可##

import os
import sys
import django
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled10.settings") 
    django.setup()

#测试models文件

from django.test import TestCase

# Create your tests here.
import os
import sys
import django
if __name__ == "__main__":
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "untitled10.settings")
    django.setup()
    from app05 import models
    models.user.objects.all()

##脚本代码无论是写在应用下的test.py文件还是自己单独开设的py文件都可以##

##所有代码都必须等待环境准备完毕后才能书写##

数据库十分重要的API：

all()

#查询所有

filter()

#带有过滤对象的查询

get()

#直接拿数据对象 但是条件不存在直接报错

first()

#拿queryset里面的第一元素

#源码：

 def first(self):
        """
        Returns the first object of a query, returns None if no match is found.
        """
        objects = list((self if self.ordered else self.order_by('pk'))[:1])
        if objects:
            return objects[0]
        return None

last()

#拿queryset里面的最后一个元素

#源码：

 def last(self):
        """
        Returns the last object of a query, returns None if no match is found.
        """
        #取反然后再索引零
        objects = list((self.reverse() if self.ordered else self.order_by('-pk'))[:1])
        if objects:
            return objects[0]
        return None

values()

#可以指定获取数据字段

#返回结果是列表套字典

 res=models.user_app05.objects.values("name")
    print(res)

#输出图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0ICMVFs-1613568064111)(C:\Users\mzy\AppData\Roaming\Typora\typora-user-images\image-20210205223835887.png)]

values_list()

#可以指定获取数据字段

#返回结果是列表套元组

 res=models.user_app05.objects.values_list("name")
    print(res)

#输出图片

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NshNwHoo-1613568064115)(C:\Users\mzy\AppData\Roaming\Typora\typora-user-images\image-20210205224149578.png)]

distinct()

#去重

#去重一定是一模一样的数据#

#如果带有主键那么肯定不一样 查询的时候注意主键

order_by()

#排序

 #默认升序
 res=models.user_app05.objects.order_by("name")
 #降序
 res = models.user_app05.objects.order_by("-name")

reverse()

#反转的前提是 数据已经排过序了（否则报错）

count()

#统计当前数据个数

res=models.user_app05.objects.count()

exclude()

#排除什么在外

res=models.user_app05.objects.exclude()

exists()

#判断什么是否存在

#存在返回true否则返回false

 res=models.user_app05.objects.filter(pk=10).exists()

#输出语句后面可以加入query可以查看内部封装的sql语句（只能是queryset对象才能用.query来查看sql语句）

 res=models.user_app05.objects.values_list("name")
    print(res.query)

#输出结果：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wq9uyFDD-1613568064117)(C:\Users\mzy\AppData\Roaming\Typora\typora-user-images\image-20210205224558462.png)]

查看内部sql语句的方法：

#方式一：

如上

#方式二：（所有语句都可以查看）

#去配置文件中修改一下

再setting.py中加入一下代码：

# 日志配置
LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'console':{
            'level':'DEBUG',
            'class':'logging.StreamHandler',
        },
    },
    'loggers': {
        'django.db.backends': {
            'handlers': ['console'],
            'propagate': True,
            'level':'DEBUG',
        },
    }
}

神奇的双下划线查询

xx__lt:小于

from django.http import HttpResponse
from app import models
def test1(request):  
    # ① xx_lt:小于
    person_lst = models.App.objects.filter(age__lt=13)
    print(person_lst)
    return HttpResponse("双下划线方法")
1234567

xx__lte:小于等于

def test1(request):
# ②xx_lte:小于等于
    person_lst = models.App.objects.filter(age__lte=13)
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__gt:大于

def test1(request):
# ③xx_gte:大于
    person_lst = models.App.objects.filter(age__gt=13)
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__gte:大于等于

def test1(request):
# ④xx_gte:大于等于
    person_lst = models.App.objects.filter(age__gte=13)
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__in:包含某些值

def test1(request):
    # ⑤xx_in:包含某些值
    person_lst = models.App.objects.filter(age__in=[11,12])
    print(person_lst)

    return HttpResponse("双下划线方法")
123456

exclude和xx__in联合使用：不包含

def test1(request):
# ⑥exclude和xx_in联合使用：不包含
    person_lst = models.App.objects.exclude(age__in=[11, 12])
    print(person_lst)
   
    return HttpResponse("双下划线方法")
123456

xx__contains（）：包含某些字符的

def test1(request):
 # ⑦xx__contains（）：包含某些字符的
    person_lst = models.App.objects.filter(name__contains='s')
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__icontains（）：包含某些字符的(忽略大小写)，sqlite3不支持

def test1(request):
 # ⑧xx__icontains（）：包含某些字符的(忽略大小写)，sqlite3不支持
    person_lst = models.App.objects.filter(name__icontains='s')
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__range（）：查找范围

def test1(request):
 # ⑨xx_range（）：查找范围
    person_lst = models.App.objects.filter(age__range=[10,15])
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__startwith:获取以 ‘ ’ 开头的记录

def test1(request):
 # ⑩ xx_startwith:获取以‘’开头的记录
    person_lst = models.App.objects.filter(age__startwith='z')
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

xx__endwith:获取以 ‘ ’ 结尾的记录

def test1(request):
 # ⑪xx_endwith:获取以‘’结尾的记录
    person_lst = models.App.objects.filter(age__endwith='z')
    print(person_lst)
    return HttpResponse("双下划线方法")
12345

date 可以根据年月日进行过滤

def test1(request):
 # ⑫date 可以根据年月日进行过滤
	#按照找日来查找
    person_lst = models.App.objects.filter(birthday__day=7)
    #按照月来查找
     person_lst = models.App.objects.filter(birthday__month=7)
    #按照年来查找
    person_lst = models.App.objects.filter(birthday__year=7)
    print(person_lst)
    
    return HttpResponse("双下划线方法")

多表操作

email=models.EmailField()   #本质是varchar（254） 该字段不是给models看的而是给校验型组件看的
phone=models.BigIntField()   #电话号码用BigIntField或者直接用CharField

#一对多的外键的增删改查

#增

#1直接写实际字段
#2虚拟子段 对象

一、一对多（外键）
例子：一个作者对应多本书，一本书只有一个作者

model代码：

class Person(models.Model);



name = models.CharField('作者姓名', max_length=10)



age = models.IntegerField('作者年龄')



 



class Book(models.Model):



person = models.ForeignKey(Person, related_name='person_book')



title = models.CharField('书籍名称', max_length=10)



pubtime = models.DateField('出版时间')

(一) 获取对象方法：

1.从作者出发获取书籍

person = Person.objects.fiter(你的条件)  



book = person.book_set.all()

2.从书籍出发获取作者

 p = book.person

二、多对多
例子：一个作者对应多本书，一本书有多个作者

model代码：

class Author(models.Model):  



    first_name = models.CharField(max_length=30)  



    last_name = models.CharField(max_length=40)  



    email = models.EmailField()  



      



class Book(models.Model):  



    title = models.CharField(max_length=200)  



    authors = models.ManyToManyField(Author)

（一）获取对象方法：
1.从书籍出发获取作者

b = Book.objects.get(id=50)



b.authors.all()   #.authors表示你已经可以操作第三张关系表了



b.authors.filter(first_name='Adam')

2.从作者出发获取书籍

a = Author.objects.get(id=1)  



a.book_set.all()

（二）添加对象方法：

a = Author.objects.get(id=1)  



b = Book.objects.get(id=50)  



b.authors.add(a)

（三）删除对象对象方法：

a = Author.objects.get(id=1)  



b = Book.objects.get(id=50)  



b.authors.remove(a) 或者 b.authors.filter(id=1).delete()

（四）修改

book_obj.author.set([1,3])   #括号内必须放一个可迭代对象（列表或字典）
#括号内必须传一个可迭代对象 该对象内即可以是数字也可以是对象 并且都支持多个

（五）清空某个书籍和作者的绑定关系

#在第三张关系表中清空某个书籍与作者的绑定关系
book_obj.authors.clear()
#clear括号内不加任何参数

转载于:https://www.cnblogs.com/nyist-xsk/p/9163721.html

正反向概念

#正向

看外键字段在哪里 哪里就是正向

外键字段不在手上 我查你是反向

#一对一和多对多正反向的判断也是如此

多表查询

子查询：（基于对象的跨表查询）

连表查询：（基于双下划线的跨表查询）

#如果出现了

app01.Author.None

#则可以在orm语句后面加入.all 然后可以查询

#在查询数据时 orm语句应该像查sql语句时 一个一个查

#正向的什么时候加.all()

当你的结果可能有多个时候需要加.all()

​ 如果是一个则直接拿到数据对象

反向查询：

反向查询:一查找多,是反向查找
无外键类的具体对象.有外键的小写类名_set
无外键类是一,有外键是多.
一的具体对象.多的类名小写_set 查到一的具体对象下的所有多的对象、

基于双下滑线的跨表查询

2 基于双下划线的跨表查询。

基于双下划线的跨表查询也分为正向查询和反向查询。

正向查询

这里面的正向查询表示：查询条件字段或者查询字段在主表中。由从表查主表。

# 查询条件字段在主表中,最终查询字段值还是在从表中。

UserDetail.objects.filter(user__pwd=123).values()

# 查询字段值在主表中，查询条件字段在从表中。

UserDetail.objects.filter(phonenum=110).values(‘user__pwd’)

反向查询

这里的反向查询表示：查询条件字段或者查询字段值在从表中，由主表查从表。

# 查询条件字段在从表中。

UserInfo.objects.filter(uuu__phonenum=110).values()

# 查询字段值在从表中。

UserInfo.objects.filter(username=‘xiao’).values(‘uuu__phonenum’)

注意：在反向查询中，优先级顺序：related_query_name > related_name > 表名

即：当related_query_name和related_name同时出现时，related_query_name或覆盖related_name,你再使用related_name会报错。当related_name出现时，而related_query_name未出现。你必须使用related_name，此时在使用表名的话会报错。

在反向查询时，在没有设置related_name的时候，基于双下划线只需使用表名，而基于对象的查询方式需要使用表名_set

#查询jason的手机号和作者姓名

res=models.Author.objects.filter(name="jason").values("author_detail__phone","name")
res=models.AuthorDwtail.object.filter(author__name="jason")
#这两个res是等价的
#第二个res是查询author表中名字为name

聚合查询aggregate（）

Max,Min,Sum,Count,Avg

    #只要是跟数据库相关的模块 基本都在django.db.models里面
    #aggregate里面可以加入多个参数
    from django.db.models import Max,Min,Sum,Count,Avg
    res=models.user_app05.objects.aggregate(Avg("price"),Max("price"))

分组查询annotate（）

#这里引用了一个很好的博客

公司员工表
这里写图片描述
按照部分分组求平均工资：

SQL语句
select dept,AVG(salary) from employee group by dept;1
ORM查询:
from django.db.models import Avg
Employee.objects.values("dept").annotate(avg=Avg("salary").values(dept, "avg")

# 另一个案例：每本书的作者人数：
models.Book.objects.all().annotate(author_num=Count("author"))


# 语法    pk字段 == 主键primary key
模型.objects.values('分组字段').annotate(聚合函数)

模型.objects.values('pk').annotate(c=Count('article__title')).values('title','c')1234567891011

连表分组

这里写图片描述

SQL语句：
select dept.name,AVG(salary) from employee inner join dept on (employee.dept_id=dept.id) group by dept_id;1
ORM查询:
from django.db.models import Avg

models.Dept.objects.annotate(avg=Avg("employee__salary")).values("name", "avg"

Q对象

用法：

Q（条件）

例如
Q(id__gt=12)
代表，id大于12的条件

Q对象通常会 与另一个Q对象进行比较，使用逻辑运算符来连接
1234567

用于查询条件之间的逻辑关系

not and or

可以对Q对象进行与或非的操作

&
|
~
123

使用前需要先导入

在这里插入图片描述

》与

django框架学习_第25张图片
在这里插入图片描述

》或

在这里插入图片描述
在这里插入图片描述

》非

在这里插入图片描述
在这里插入图片描述

模型类.objects.exclude(id=3)

F 对象

用法：

F(字段）
1

用于模型类对象属性之间的比较

》使用前要先导入

在这里插入图片描述

》

在这里插入图片描述

查阅读量大于30

bread__gt=30

在这里插入图片描述
django框架学习_第26张图片

》

在这里插入图片描述

django中开启事务

事务：
ACID

​ 原子性

​ 不可分割的最小单位

​ 一致性

​ 跟原子性是相辅相成

​ 隔离性

​ 事务之间互相不干扰

​ 持久性

​ 事务一旦确定永久有效

事务的回滚

​ rollback

事务的确认

​ commit

    from django.db.models import Max,Min,Sum,Count,Avg
    res=models.user_app05.objects.aggregate(Avg("age"))
    print(res)
    #事务
    from django.db import transaction
    try:
        with transaction.atomic():
            #sql1
            #sql2
            #在with代码块内书写的所有的orm操作都是属于同一个事务
            pass
    except Exception as e:
        print(e)
    print("执行其他操作")

orm常用字段及操作

常用字段和参数

1.ORM字段

  • AutoField

    int自增列，必须填入参数 primary_key=True。当model中如果没有自增列，则自动会创建一个列名为id的列。

  • IntegerField

    一个整数类型,范围在 -2147483648 to 2147483647。

  • CharField

    字符类型，必须提供max_length参数， max_length表示字符长度。

  • DateField

    日期字段，日期格式 YYYY-MM-DD，相当于Python中的datetime.date()实例。

  • DateTimeField

    日期时间字段，格式 YYYY-MM-DD HH:MM:ss，相当于Python中的datetime.datetime()实例

常用和非常用字段
AutoField(Field)
        - int自增列，必须填入参数 primary_key=True

    BigAutoField(AutoField)
        - bigint自增列，必须填入参数 primary_key=True

        注：当model中如果没有自增列，则自动会创建一个列名为id的列
        from django.db import models

        class UserInfo(models.Model):
            # 自动创建一个列名为id的且为自增的整数列
            username = models.CharField(max_length=32)

        class Group(models.Model):
            # 自定义自增列
            nid = models.AutoField(primary_key=True)
            name = models.CharField(max_length=32)

    SmallIntegerField(IntegerField):
        - 小整数 -32768 ～ 32767

    PositiveSmallIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正小整数 0 ～ 32767
    IntegerField(Field)
        - 整数列(有符号的) -2147483648 ～ 2147483647

    PositiveIntegerField(PositiveIntegerRelDbTypeMixin, IntegerField)
        - 正整数 0 ～ 2147483647

    BigIntegerField(IntegerField):
        - 长整型(有符号的) -9223372036854775808 ～ 9223372036854775807

    BooleanField(Field)
        - 布尔值类型
		- 会存成一或者零
    NullBooleanField(Field):
        - 可以为空的布尔值

    CharField(Field)
        - 字符类型
        - 必须提供max_length参数， max_length表示字符长度
        -verbose_name 字段的注释

    TextField(Field)
        - 文本类型
		- 该字段可以存大段文本（没有字数限制）
    EmailField(CharField)：
        - 字符串类型，Django Admin以及ModelForm中提供验证机制
        -等价于varchar(254)

    IPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 IPV4 机制

    GenericIPAddressField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供验证 Ipv4和Ipv6
        - 参数：
            protocol，用于指定Ipv4或Ipv6， 'both',"ipv4","ipv6"
            unpack_ipv4， 如果指定为True，则输入::ffff:192.0.2.1时候，可解析为192.0.2.1，开启此功能，需要protocol="both"

    URLField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证 URL

    SlugField(CharField)
        - 字符串类型，Django Admin以及ModelForm中提供验证支持 字母、数字、下划线、连接符（减号）

    CommaSeparatedIntegerField(CharField)
        - 字符串类型，格式必须为逗号分割的数字

    UUIDField(Field)
        - 字符串类型，Django Admin以及ModelForm中提供对UUID格式的验证

    FilePathField(Field)
        - 字符串，Django Admin以及ModelForm中提供读取文件夹下文件的功能
        - 参数：
                path,                      文件夹路径
                match=None,                正则匹配
                recursive=False,           递归下面的文件夹
                allow_files=True,          允许文件
                allow_folders=False,       允许文件夹

    FileField(Field)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = "/data"      
   #上传文件的保存路径 给该字段传一个文件对象，会自动将文件保存在/data目录下然后将文件路径保存在数据库里
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage

    ImageField(FileField)
        - 字符串，路径保存在数据库，文件上传到指定目录
        - 参数：
            upload_to = ""      上传文件的保存路径
            storage = None      存储组件，默认django.core.files.storage.FileSystemStorage
            width_field=None,   上传图片的高度保存的数据库字段名（字符串）
            height_field=None   上传图片的宽度保存的数据库字段名（字符串）

    DateTimeField(DateField)
        - 日期+时间格式 YYYY-MM-DD HH:MM[:ss[.uuuuuu]][TZ]
        -auto_now:每次修改数据都会自动更新当前时间
        -auto_now_add:只在创建数据的时候记录创建时间后不会自动修改

    DateField(DateTimeCheckMixin, Field)
        - 日期格式      YYYY-MM-DD

    TimeField(DateTimeCheckMixin, Field)
        - 时间格式      HH:MM[:ss[.uuuuuu]]

    DurationField(Field)
        - 长整数，时间间隔，数据库中按照bigint存储，ORM中获取的值为datetime.timedelta类型

    FloatField(Field)
        - 浮点型

    DecimalField(Field)
        - 10进制小数
        - 参数：
            max_digits，小数总长度
            decimal_places，小数位长度

    BinaryField(Field)
        - 二进制类型

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116
对应关系
对应关系：
    'AutoField': 'integer AUTO_INCREMENT',
    'BigAutoField': 'bigint AUTO_INCREMENT',
    'BinaryField': 'longblob',
    'BooleanField': 'bool',
    'CharField': 'varchar(%(max_length)s)',
    'CommaSeparatedIntegerField': 'varchar(%(max_length)s)',
    'DateField': 'date',
    'DateTimeField': 'datetime',
    'DecimalField': 'numeric(%(max_digits)s, %(decimal_places)s)',
    'DurationField': 'bigint',
    'FileField': 'varchar(%(max_length)s)',
    'FilePathField': 'varchar(%(max_length)s)',
    'FloatField': 'double precision',
    'IntegerField': 'integer',
    'BigIntegerField': 'bigint',
    'IPAddressField': 'char(15)',
    'GenericIPAddressField': 'char(39)',
    'NullBooleanField': 'bool',
    'OneToOneField': 'integer',
    'PositiveIntegerField': 'integer UNSIGNED',
    'PositiveSmallIntegerField': 'smallint UNSIGNED',
    'SlugField': 'varchar(%(max_length)s)',
    'SmallIntegerField': 'smallint',
    'TextField': 'longtext',
    'TimeField': 'time',
    'UUIDField': 'char(32)',
123456789101112131415161718192021222324252627

2.ORM字段参数

  • null

    用于表示某个字段可以为空。

  • unique

    如果设置为unique=True 则该字段在此表中必须是唯一的 。

  • db_index

    如果db_index=True 则代表着为此字段设置索引。

  • default

    为该字段设置默认值。

DateField和DateTimeField
  • auto_now_add

    配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。

  • auto_now

    配置上auto_now=True，每次更新数据记录的时候会更新该字段。

了解
null                数据库中字段是否可以为空
    db_column           数据库中字段的列名
    db_tablespace
    default             数据库中字段的默认值
    primary_key         数据库中字段是否为主键
    db_index            数据库中字段是否可以建立索引
    unique              数据库中字段是否可以建立唯一索引
    unique_for_date     数据库中字段【日期】部分是否可以建立唯一索引
    unique_for_month    数据库中字段【月】部分是否可以建立唯一索引
    unique_for_year     数据库中字段【年】部分是否可以建立唯一索引

    verbose_name        Admin中显示的字段名称
    blank               Admin中是否允许用户输入为空
    editable            Admin中是否可以编辑
    help_text           Admin中该字段的提示信息
    choices             Admin中显示选择框的内容，用不变动的数据放在内存中从而避免跨表操作
                        如：gf = models.IntegerField(choices=[(0, '何穗'),(1, '大表姐'),],default=1)

    error_messages      自定义错误信息（字典类型），从而定制想要显示的错误信息；
                        字典健：null, blank, invalid, invalid_choice, unique, and unique_for_date
                        如：{'null': "不能为空.", 'invalid': '格式错误'}

    validators          自定义错误验证（列表类型），从而定制想要的验证规则
                        from django.core.validators import RegexValidator
                        from django.core.validators import EmailValidator,URLValidator,DecimalValidator,\
                        MaxLengthValidator,MinLengthValidator,MaxValueValidator,MinValueValidator
                        如：
                            test = models.CharField(
                                max_length=32,
                                error_messages={
                                    'c1': '优先错信息1',
                                    'c2': '优先错信息2',
                                    'c3': '优先错信息3',
                                },
                                validators=[
                                    RegexValidator(regex='root_\d+', message='错误了', code='c1'),
                                    RegexValidator(regex='root_112233\d+', message='又错误了', code='c2'),
                                    EmailValidator(message='又错误了', code='c3'), ]
                            )

1234567891011121314151617181920212223242526272829303132333435363738394041

3.关系字段

3.1ForeignKey(to，to_field，on_delete,db_constraint)

外键类型在ORM中用来表示外键关联关系，一般把ForeignKey字段设置在 '一对多’中’多’的一方。ForeignKey可以和其他表做关联关系同时也可以和自身做关联关系。

to:设置要关联的表

to_field:设置要关联的表的字段

related_name:反向操作时，使用的字段名，用于代替原反向查询时的'表名_set'。但不建议使用

related_query_name:反向查询操作时，使用的连接前缀，用于替换表名。

on_delete:当删除关联表中的数据时，当前表与其关联的行的行为。

　　models.CASCADE
　　删除关联数据，与之关联也删除

　　models.DO_NOTHING
　　删除关联数据，引发错误IntegrityError

　　models.PROTECT
　　删除关联数据，引发错误ProtectedError

　　models.SET_NULL
　　删除关联数据，与之关联的值设置为null（前提FK字段需要设置为可空）

　　models.SET_DEFAULT
　　删除关联数据，与之关联的值设置为默认值（前提FK字段需要设置默认值）

　　models.SET
　　删除关联数据，
　　a. 与之关联的值设置为指定值，设置：models.SET(值)
　　b. 与之关联的值设置为可执行对象的返回值，设置：models.SET(可执行对象)
　　
db_constraint:是否在数据库中创建外键约束，默认为True。可以设置为False。

1234567891011121314151617181920212223242526272829303132
3.2 OneToOneField

一对一字段。通常一对一字段用来扩展已有字段。一对一的关联关系多用在当一张表的不同字段查询频次差距过大的情况下，将本可以存储在一张表的字段拆开放置在两张表中，然后将两张表建立一对一的关联关系。

to:设置要关联的表

to_field:设置要关联的表的字段

on_delete:同ForeignKey字段。
12345
3.3 ManyToManyField
to:设置要关联的表

to_field:设置要关联的表的字段

related_query_name:反向查询操作时，使用的连接前缀，用于替换表名。

symmetrical:仅用于多对多自关联时，指定内部是否创建反向操作的字段。默认为True。

through:设置关联的字段。

through_fields:设置关联的字段。

db_table:默认创建第三张表时，数据库中表的名称。
12345678910111213

4.多对多关联关系的三种方式

方式一：自行创建第三张表
class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")


# 自己创建第三张表，分别通过外键关联书和作者
class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")
123456789101112131415
方式二：通过ManyToManyField自动创建第三张表
class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 通过ORM自带的ManyToManyField自动创建第三张表
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", related_name="authors")
12345678
方式三：设置ManyTomanyField并指定自行创建的第三张表
class Book(models.Model):
    title = models.CharField(max_length=32, verbose_name="书名")


# 自己创建第三张表，并通过ManyToManyField指定关联
class Author(models.Model):
    name = models.CharField(max_length=32, verbose_name="作者姓名")
    books = models.ManyToManyField(to="Book", through="Author2Book", through_fields=("author", "book"))
    # through_fields接受一个2元组（'field1'，'field2'）：
    # 其中field1是定义ManyToManyField的模型外键的名（author），field2是关联目标模型（book）的外键名。


class Author2Book(models.Model):
    author = models.ForeignKey(to="Author")
    book = models.ForeignKey(to="Book")

    class Meta:
        unique_together = ("author", "book")
123456789101112131415161718

注意：

当我们需要在第三张关系表中存储额外的字段时，就要使用第三种方式。

但是当我们使用第三种方式创建多对多关联关系时，就无法使用set、add、remove、clear方法来管理多对多的关系了，需要通过第三张表的model来管理多对多关系。

5.元信息

ORM对应的类里面包含另一个Meta类，而Meta类封装了一些数据库的信息。主要字段如下:

  • db_table

    ORM在数据库中的表名默认是 app_**类名，可以通过**db_table可以重写表名。

  • index_together

    联合索引。

  • unique_together

    联合唯一索引。

  • ordering

    指定默认按什么字段排序。

    只有设置了该属性，我们查询到的结果才可以被reverse()。

class UserInfo(models.Model):
        nid = models.AutoField(primary_key=True)
        username = models.CharField(max_length=32)

        class Meta:
            # 数据库中生成的表名称 默认 app名称 + 下划线 + 类名
            db_table = "table_name"

            # 联合索引
            index_together = [
                ("pub_date", "deadline"),
            ]

            # 联合唯一索引
            unique_together = (("driver", "restaurant"),)
            
            ordering = ('name',)
            
            # admin中显示的表名称
            verbose_name='哈哈'

            # verbose_name加s
            verbose_name_plural=verbose_name

数据库查询优化

only和defer

only是只拿某一个字段的所有值，而defer是拿出除了某一个字段之外的所有值

select_related与prefetch_related

select_related内部直接将book与publish表连在一起 然后一次性将大表里面的所有数据全部封装给查询出来的对象 这时候无论点book还是点publish的数据都无需走数据库查询

##selcet_related只能放外键字段 一对一关系 和 一对多关系

##多对多不行

prefetch_related内部其实是子查询 将子查询查询出来的所有结果封装到对象中

orm语句特点：

惰性查询

​ 如果你只是仅仅只是书写了orm语句 在后面根本没有用到该语句所查询出来的参数

​ 那么orm会自动识别 直接不执行

  res=models.user_app05.objects.only("register_time")    #只拿register_time这一个字段的所有值
    res=models.user_app05.objects.all()                    #拿出表中的所有值（较慢）
    res=models.user_app05.objects.defer("register_time") 
    for i in res:
        print(res.register_time)
        print(res.name)  #这一步会重新走数据库

图书管理系统设计

略

choices参数（数据库字段设计常见）

针对一个可以列举完全的可能性字段，我们如何储存

gender_choices=(
(1,"male"),
(2,"female"),
)
gender=models.InterField(choices=gender_choices)
##该gender字段存的还是数字 但是如果存的数字在上面元组列举的范围之内
##那么可以非常轻松的获取到数字对应的真正内容
1.gender字段存的数字不在上述元组的列举范围内容
2.如果在 如何获取对应的中文信息      
user_obj=models.user.objects.filter(pk=1).first()   #获取主键值等于一的这一对象
#只要是choices参数的字段 如果想要获得对应信息 固定写法 get_字段名_display()  
#如果没有对应关系会返回对应关系值
user_obj.get_gender_display()

MTV与MVC模型

#MTV:DJANO号称是HTV模型

M：models

T：templates

v：views

#HTV：其实django本质也是HVC

H：models

V：views

C：controller

#vue框架：HVVM框架

多对多三种创建方式：

这里引用了一个博客

Django ORM多对多的三种模式

  1. 使用默认的ManyToManyField创建第三张表、

  2. 自己创建第三张关系表
    3.自己创建第三张表，在ManyToManyField中通过through和through_fields指定表名和字段

    books=models.ManyToManyField(to="book",
                             through="BOOK2AUTHOR", #表名
                             through_fields=("author","book")  #关联字段
)

    #半自动：可以使用orm的正反向查询 但无法使用add，set，remove，clear这四个方法

回到顶部
Django ORM多对多的三种模式

  1. 使用默认的ManyToManyField创建第三张表、
  2. 优势
    可以使用ORM提供的快捷方法
    add()
    clear()
    set()
    remove()
    all()
  3. 劣势：
    不能扩展第三张表

复制代码
from django.db import models

Create your models here.

class Book(models.Model):
title = models.CharField(max_length=32)

def __str__(self):
    return self.title
12

class Author(models.Model):
name = models.CharField(max_length=32, verbose_name=“作者姓名”)
books = models.ManyToManyField(to=‘Book’)

def __str__(self):
    return self.name
12

复制代码

复制代码
#!/usr/bin/env python

-- coding:utf8 --

import os

if name == ‘main’:
os.environ.setdefault(“DJANGO_SETTINGS_MODULE”, “manytomany_test.settings”)
import django
django.setup()

from app01 import models

author_obj = models.Author.objects.get(id=1)
ret = author_obj.books.all()
print(ret)

# from app02 import models
#
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.author2book_set.all().values_list("book__title")
# print(ret)

# from app03 import models
# 
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.books.all()
# print(ret)
# 删除第一个作者关联的所有书籍，可以直接操作第三张关系表
# models.Author2Book.objects.filter(author=author_obj).delete()
12345678910111213141516171819

复制代码
\2. 自己创建第三张关系表

  1. 优势：
    可以自己扩展第三章关系表的字段（婚恋网站的男女用户的约会记录）
  2. 劣势：
    不能使用ORM提供的快捷方法(查询麻烦，需要跨三张表)

复制代码
from django.db import models

Create your models here.

class Book(models.Model):
title = models.CharField(max_length=32, verbose_name=“书名”)

def __str__(self):
    return self.title
12

class Author(models.Model):
name = models.CharField(max_length=32, verbose_name=“作者姓名”)

def __str__(self):
    return self.name
12

自己创建多对多的第三张表

class Author2Book(models.Model):
book = models.ForeignKey(to=‘Book’)
author = models.ForeignKey(to=‘Author’)

class Meta:
    unique_together = (('book', 'author'), )
12

复制代码

复制代码
#!/usr/bin/env python

-- coding:utf8 --

import os

if name == ‘main’:
os.environ.setdefault(“DJANGO_SETTINGS_MODULE”, “manytomany_test.settings”)
import django
django.setup()

# from app01 import models
# 
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.books.all()
# print(ret)

from app02 import models

author_obj = models.Author.objects.get(id=1)
ret = author_obj.author2book_set.all().values_list("book__title")  # 先是外键反向查询， 在是外键正向查询
print(ret)

# from app03 import models
#
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.books.all()
# print(ret)
# 删除第一个作者关联的所有书籍，可以直接操作第三张关系表
# models.Author2Book.objects.filter(author=author_obj).delete()
12345678910111213141516171819

复制代码
3.自己创建第三张表，在ManyToManyField中通过through和through_fields指定表名和字段

  1. 优势：
    可以使用ORM提供的部分快捷方法
    all()
    可以扩展第三张关系表的字段

复制代码
from django.db import models

Create your models here.

class Book(models.Model):
title = models.CharField(max_length=32, verbose_name=“书名”)

def __str__(self):
    return self.title
12

class Author(models.Model):
name = models.CharField(max_length=32, verbose_name=“作者姓名”)
books = models.ManyToManyField(
to=‘Book’,
through=‘Author2Book’,
through_fields=(‘author’, ‘book’) # 这里是有顺序的，在那个表种写关联，那个字段就要写的前面
)

def __str__(self):
    return self.name
12

自己创建多对多的第三张表

class Author2Book(models.Model):
book = models.ForeignKey(to=‘Book’)
author = models.ForeignKey(to=‘Author’)

class Meta:
    unique_together = (('book', 'author'),)
12

复制代码

复制代码
#!/usr/bin/env python

-- coding:utf8 --

import os

if name == ‘main’:
os.environ.setdefault(“DJANGO_SETTINGS_MODULE”, “manytomany_test.settings”)
import django
django.setup()

# from app01 import models
#
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.books.all()
# print(ret)

# from app02 import models
# 
# author_obj = models.Author.objects.get(id=1)
# ret = author_obj.author2book_set.all().values_list("book__title")  # 先是外键反向查询， 在是外键正向查询
# print(ret)

from app03 import models

author_obj = models.Author.objects.get(id=1)
ret = author_obj.books.all()  # 只可使用多对多关系种的all()方法
print(ret)

# 删除第一个作者关联的所有书籍，可以直接操作第三张关系表
models.Author2Book.objects.filter(author=author_obj).delete()
1234567891011121314151617181920

Ajax

异步提交

局部更新

例子：github注册

动态获取用户名实时的跟后端确认并且实时展示到前端（局部刷新）

朝前端发送请求的方式：
1·浏览器地址栏直接输入url回车   GET请求
2·a标签的href属性             GET请求
3·form表单                   GET请求/POST请求
4·ajax                       GET请求/POST请求

一个很好的博客

AJAX 不是新的编程语言 而是一种使用现有标准的新方法（比较装饰器）

AJAX 最大的有点式在不重新加载整个页面的情况下，可以与服务器交换数据并且更新部分网页内容。

AJAX我们只学习jQuery封装之后的版本（不学原装的 原生的复杂并且在实际项目中也一般不用）

ps:jQury只是实现ajax的一个框架 其他框架也可以

小例子：

一个ajax例子：


<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
     {#  //导入jquery模块（注意这个一定要导入）   #}
    <script src="https://cdn.bootcss.com/jquery/3.3.1/jquery.min.js">script>
head>
<body>
  <input type="text" id="d1">+
   <input type="text" id="d2">=
 <input type="text" id="d3">
<p>
    <button id="btn">点我button>
p>
<script>
    //给按钮绑定点击事件
    $('#btn').click(function () {
    //绑定后发送ajax请求
        $.ajax({
            //1·指定朝那个后端发送ajax请求
            url:"",   //不写向当前地址提交
            //2.请求方法
            type:"post", //不指定默认就是get
            //3.数据
            {#拿到第一个和第二个i1和i2的值#}
            data:{"i1":$('#d1').val(),"i2":$("#d2").val()},
            dataType:true,  //会字动帮你反序列化
            //或者在后端用jsonresponse会回调函数会字动反序列化十分方便
            //4.回调函数:当后端返回结果的时候会自动触发 args接收后端的返回结果
            success:function (args) {
                {#alert(args)#}
                {#通过DOM操作动态渲染到第三个input里面#}
                $("#d3").val(args)
                Console.log(typeof args)
            {#  json.parse(args) 把字符串转换为字典 然后再用点操作获取值   #}
            }
        })
    })
            script>
body>


html>

后端：

from django.shortcuts import render,HttpResponse
import json
from django.http import JsonResponse
# Create your views here
def ab_ajax(request):
    if request.method=="POST":
        i1=request.POST.get("i1")
        i2=request.POST.get("i2")
        print(request.POST)
        i3=int(i1)+int(i2)
        print(i3)
        #这里返回字典
        d={"code":100,"msg":i3}
        #return HttpResponse(json.dumps(d))
        #jsonresponse可以直接在前端序列化
        return JsonResponse(d)
    return render(request,"index_ajax.html")

##django差个结尾，但觉得还有好多东西没学看来以后永远是一个咸鱼了QAQ##

你可能感兴趣的:(python,网络编程,django)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • Python编译器 鹿鹿~ Python编译器Pythonpython开发语言后端
    嘿嘿嘿我又来了啊有些小盆友可能不知道Python其实是有编译器的，也就是PyCharm。你们可能会问到这个是干嘛的又不可以吃也不可以穿好像没有什么用，其实你还说对了这个还真的不可以吃也不可以穿，但是它用来干嘛的呢。用来编译你所打出的代码进行运行（可能这里说的有点不对但是只是个人认为）现在我们来说说PyCharm是用来干嘛的。PyCharm是一种PythonIDE，带有一整套可以帮助用户在使用Pyt
  • 一文掌握python面向对象魔术方法（二） 程序员neil pythonpython开发语言
    接上篇：一文掌握python面向对象魔术方法（一）-CSDN博客目录六、迭代和序列化：1、__iter__(self):定义迭代器，使得类可以被for循环迭代。2、__getitem__(self,key):定义索引操作，如obj[key]。3、__setitem__(self,key,value):定义赋值操作，如obj[key]=value。4、__delitem__(self,key):定义
  • 一文掌握python常用的list（列表）操作 程序员neil pythonpython开发语言
    目录一、创建列表1.直接创建列表：2.使用list()构造器3.使用列表推导式4.创建空列表二、访问列表元素1.列表支持通过索引访问元素，索引从0开始：2.还可以使用切片操作访问列表的一部分：三、修改列表元素四、添加元素1.append()：在末尾添加元素2.insert()：在指定位置插入元素五、删除元素1.del：删除指定位置的元素2.remove()：删除指定值的第一个匹配项3.pop()：
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • python中的深拷贝与浅拷贝 anshejd70787 python
    深拷贝和浅拷贝浅拷贝的时候，修改原来的对象，浅拷贝的对象不会发生改变。1、对象的赋值对象的赋值实际上是对象之间的引用：当创建一个对象，然后将这个对象赋值给另外一个变量的时候，python并没有拷贝这个对象，而只是拷贝了这个对象的引用。当对对象做赋值或者是参数传递或者作为返回值的时候，总是传递原始对象的引用，而不是一个副本。如下所示：>>>aList=["kel","abc",123]>>>bLis
  • 用Python实现简单的猜数字游戏 程序媛了了 python游戏java
    猜数字游戏代码：importrandomdefpythonit():a=random.randint(1,100)n=int(input("输入你猜想的数字："))whilen!=a:ifn>a:print("很遗憾，猜大了")n=int(input("请再次输入你猜想的数字："))elifna::如果玩家猜的数字n大于随机数字a，则输出"很遗憾，猜大了"，并提示玩家再次输入。elifn
  • SAX解析xml文件 小猪猪08 xml
    1.创建SAXParserFactory实例 2.通过SAXParserFactory对象获取SAXParser实例 3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 4.SAXParser实例的parse来获取文件     public static void main(String[] args) { //
  • 为什么mysql里的ibdata1文件不断的增长？ brotherlamp linuxlinux运维linux资料linux视频linux运维自学
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： ibdata1存了什么？ 当你启用了 i
  • Quartz-quartz.properties配置 eksliang quartz
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。   下面是这些默认值的解释 #-----集群的配置 org.quartz.scheduler.instanceName =
  • informatica session的使用 18289753290 workflowsessionlogInformatica
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 session下面的source 里面有个tracing 
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误 酷的飞上天空 scrapy
    Scrapy版本0.14.4 出现问题现象： ERROR: Error downloading <GET http://xxxxx  CRC check failed   解决方法   1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0'   明确表示不支持任何形式的压缩格式，避免程序的解压
  • java Swing小集锦 永夜-极光 java swing
    1.关闭窗体弹出确认对话框   1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE);   1.2   this.addWindowListener ( new WindowAdapter () { public void windo
  • 强制删除.svn文件夹 随便小屋 java
              在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。 aijuans get post
        如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历      前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。     这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
  • 谈谈新浪微博背后的那些算法 aoyouzi 谈谈新浪微博背后的那些算法
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
  • Connection reset 连接被重置的解决方法 百合不是茶 java字符流连接被重置
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置   被重置的代码如下;   客户端代码; package 通信软件服务器; import java.io.BufferedWriter; import java.io.OutputStream; import java.io.O
  • web.xml配置详解之filter bijian1013 javaweb.xmlfilter
    一.定义 <filter> <filter-name>encodingfilter</filter-name> <filter-class>com.my.app.EncodingFilter</filter-class> <init-param> <param-name>encoding<
  • Heritrix Bill_chen 多线程xml算法制造配置管理
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
  • 【Zookeeper】FAQ bit1129 zookeeper
    1.脱离IDE，运行简单的Java客户端程序 #ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient    1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 2. 如果Zookeeper集群跨越多个机房，那么Leader/
  • The user specified as a definer ('aaa'@'localhost') does not exist 白糖_ localhost
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 最后找原因发现删除操作做了触发器，而触发器里面有这样一句 /*!50017 DEFINER = ''aaa@'localhost' */  原来最初
  • javascript中showModelDialog刷新父页面 bozch JavaScript刷新父页面showModalDialog
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行：       window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self       在子页面使用w
  • 编程之美-买书折扣 bylijinnan 编程之美
    import java.util.Arrays; public class BookDiscount { /**编程之美 买书折扣 书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。 下面用动态规划实现。 哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要 chenbowen00 strutsWEB安全
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 下面记录下本次解决的过程以便后续 1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 而使用ftp协议默认会产生一个匿名用
  • [电力与暖气]煤炭燃烧与电力加温 comsci
          在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区.....       不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢?   &nbs
  • oracle O7_DICTIONARY_ACCESSIBILITY参数 daizj oracle
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
  • 比较全面的MySQL优化参考 dengkane mysql
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。   1、硬件层相关优化   1.1、CPU相关   在服务器的BIOS设置中，可
  • C语言homework2，有一个逆序打印数字的小算法 dcj3sjt126com c
    #h1#   0、完成课堂例子 1、将一个四位数逆序打印 1234 ==> 4321 实现方法一： # include <stdio.h> int main(void) { int i = 1234; int one = i%10; int two = i / 10 % 10; int three = i / 100 % 10;
  • apacheBench对网站进行压力测试 dcj3sjt126com apachebench
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。
  • 2种办法让HashMap线程安全 flyfoxs javajdkjni
    多线程之--2种办法让HashMap线程安全 多线程之--synchronized 和reentrantlock的优缺点 多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync)     HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全.  
  • Spring Security（04）——认证简介 234390216 Spring Security认证过程
    认证简介 目录 1.1     认证过程 1.2     Web应用的认证过程 1.2.1    ExceptionTranslationFilter 1.2.2    在request之间共享SecurityContext   1
  • Java 位运算 Javahuhui java位运算
    // 左移( << ) 低位补0 // 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： // 0000 0000 0000 0000 0000 0000 0001 1000 System.out.println(6 << 2);// 运行结果是24 // 右移( >> ) 高位补"
  • mysql免安装版配置 ldzyz007 mysql
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 3、my-large.ini是为专用于一个SQL数据
  • MFC和ado数据库使用时遇到的问题 你不认识的休道人 sqlC++mfc
    =================================================================== 第一个 =================================================================== try{ CString sql; sql.Format("select * from p
  • 表单重复提交Double Submits rensanning double
    可能发生的场景： *多次点击提交按钮 *刷新页面 *点击浏览器回退按钮 *直接访问收藏夹中的地址 *重复发送HTTP请求（Ajax） （1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： http://getbootstrap.co
  • Java String 十大常见问题 tomcat_oracle java正则表达式
    　1.字符串比较，使用“==”还是equals()? 　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。 　　equals()判断两个字符串的值是否相等。 　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。 　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。 　 　
  • SpringMVC 登陆拦截器实现登陆控制 xp9802 springMVC
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。   实现方法： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他