MVC的产生理念：分工。让专门的人去做专门的事。
MVC的核心思想：解耦
M：model模型，和数据库进行交互
V：view视图，产生HTML页面
C：controller控制器，接收请求，进行处理，与M，V进行交互，返回应答
本质上还是MVC的思想
M：model模型，和MVC中M功能相同，和数据库进行交互
V：View视图，和MVC中C功能相同，接收请求，进行处理，与M和T进行交互，返回应答
T：template模板，和MVC中V功能相同，产生HTML页面
pip install virtualenv #安装虚拟环境
pip install virtualenvwrapper #安装虚拟环境扩展包
vim .bashrc #添加以下两行
export WORKON_HOME=$HOME/.vitualenvs
source /usr/bin/virtualenvwrapper.sh
使用source .bashrc使其生效
创建python3虚拟环境
mkvirtualenv -p python3 虚拟环境名
workon 虚拟环境名 #进入虚拟环境
deactivate #退出虚拟环境命令：django-admin startproject myobj
init:说明myobj是一个python包
settings.py:项目的配置文件
urls.py:进行url路由的配置
wsgi.py:web服务器和Django交互的入口
manage.py:项目的管理文件
命令：python manage.py startapp appname
init .py:说明目录是一个Python模块
models.py:写和数据库项目的内容
views.py:接收请求，进行处理，与M和T进行交互，返回应答。定义处理函数，视图函数
test.py:写测试代码文件
admin.py:网站后台管理相关的文件
修改settings.py的INSTALLED_APPS的内容，添加应用名字
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'test1',
]python manage.py runserver
访问127.0.0.1:8000可以查看创建的应用修改settings.py文件
LANGUAGE_CODE = 'zh-hans' #使用中文
TIME_ZONE = 'Asia/Shanghai' #中国时区命令：python manage.py createsuperuser
登录后台
浏览器输入"127.0.0.1/admin"进入后台管理页面在应用下的admin.py下注册模型类
告诉Django框架根据注册的模型来生成对应表管理页面
b=Bookinfo()
str(b)
class AreaInfoAdmin(admin.ModelAdmin):
'''地区模型管理类'''
list_per_page=10 #指定每页显示10条数据顶部显示的属性，设置为True在顶部显示，设置为False不在顶部显示，默认为Trueactions_on_top=True
底部显示的属性，设置为True在底部显示，设置为False不在底部显示，默认为Falseactions_on_bottom=False
属性如下：list_display=[模型字段1,模型字段2,...]
方法列是不能排序的，如果需要排序需要为方法指定排序依据admin_order_field=模型类字段
打开booktest/models.py文件，修改AreaInfo类如下：
class AreaInfo(models.Model):
...
def title(self):
return self.atitle
title.admin_order_field='atitle'列标题默认为属性或方法的名称，可以通过属性设置。需要先将模型字段封装成方法，再对方法使用这个属性，模型字段不能直接使用这个属性short_description='列标题'
vim booktest/models.py文件，修改AreaInfo类如下：
class AreaInfo(models.Model):
...
title.short_description='区域名称'属性如下，只能接收字段，会将对应字段的值列出来，用于快速过滤。一般用于有重复值的字段。list_filter=[]
属性如下，用于对指定字段的值进行搜索，支持模糊查询。列表类型，表示在这些字段上进行搜索。search_fields=[]
属性如下：fields=[]
vim booktest/admin.py
class AreaAdmin(admin.ModelAdmin):
...
fields=['aprent','atitle']属性如下：
fieldset=(
('组1标题',{'fields':('字段1'，'字段2')}),
('组2标题',{'fields':('字段3','字段4')}),
)vim booktest/admin.py文件，修改AreaAdmin类如下：
class AreaAdmin(admin.ModelAdmin):
...
#fields=['aparent','atitle']
fieldsets=(
('基本',{'fields':['atitle']}),
('高级',{'fields':['aparent']})
)在一对多的关系中，可以在一端的编辑页面中编辑多端的对象，嵌入多端对象的方式包括表格、块两种。类型InlineModelAdmin:表示在模型的编辑页面嵌入关联模型的编辑。子类Tabularlnline：以表格的形式嵌入。子类StackedInline：以块的形式嵌入。
打开booktest/admin.py文件，创建AreaStackedInline类。
class AreaStackedInline(admin.StackedInline):
model=AreaInfo #关联子对象
extra=2 #额外编辑2个子对象打开booktest/admin.py文件，修改AreaAdmin类如下：
class AreaAdmin(admin.ModelAdmin):
...
inlines=[AreaStackedInline]Object:对象-类
Mapping:映射，建立类与表的对应关系
Relation:关系，关系数据库中的表
Django中内嵌了orm框架，orm框架可以通过类和对象操作对应的数据表，不需要写sql语句
创建模型类
#图书类
class BookInfo(models.Model):
'''图书模型类'''
#图书名称，Charfield说明是一个字符串，max_length指定字符串的最大长度
btitle=models.CharField(max_length=20)
#出版日期，DateField说明是一个日期类型
bpub_date=models.DateField()orm另外一个作用：根据设计的类生成数据库中的表
往表中添加数据
python manage.py shell
>>> from test1.models import BookInfo
>>> b=BookInfo()
>>> b.btitle='天龙八部'
>>> from datetime import date
>>> b.bpub_date=date(1990,1,1)
>>> b.save()
>>> BookInfo.objects.get(id=1)
<BookInfo: BookInfo object (1)>
>>> b2=BookInfo.objects.get(id=1)
>>> b2.btitle
'天龙八部'
>>> b2.bpub_date
datetime.date(1990, 1, 1)
>>> b2.id
1
>>> b2.bpub_date=date(2019,1,1)
>>> b2.save()
>>> b3=BookInfo.objects.get(id=1)
>>> b3.bpub_date
datetime.date(2019, 1, 1)
>>> b2.delete()
(1, {'test1.BookInfo': 1})
vim models.py
class HeroInfo(models.Model):
hname =models.CharField(max_length=20) #英雄名称
#性别，Booleanfield说明是bool类型，default指定默认值，False代表男
hgender=models.BooleanField(default=False)
#备注
hcomment=models.CharField(max_length=128)
#关系属性 hbook，建立图书类和英雄人物类之间的一对多关系
#关系属性对应的表的字段名格式：关系属性名_id
hbook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,)生成迁移文件 python3 manage.py makemigrations
执行迁移文件生成表python3 manage.py migrate
往表中操作数据python manage.py shell
from test1.models import BookInfo,HeroInfo
b=BookInfo()
b.btitle='天龙八部'
from datetime import date
b.bpub_date=date(1990,1,1)
b.save()
h=HeroInfo()
h.hname='段誉'
h.hgender=False
h.hcomment='六脉神剑'
h.hbook=b
h.save()
h3=HeroInfo()
h3.hname='乔峰'
h3.hcomment='降龙十八掌'
h3.hbook=b
h3.save()
h4=HeroInfo.objects.get(id=2)
h4.hname
'乔峰'
h4.hgender
False
h4.hcomment
'降龙十八掌'
h4.hbook_id
3
h4.hbook.btitle
'天龙八部'使用时需要引入django.db.models包，字段类型如下：
| 类型 | 描述 |
|---|---|
| AutoField | 自动增长的integerfield,通常不用指定，不指定是Django会自动创建属性名为id的自动增长属性 |
| BooleanField | 布尔字段，值为True或False |
| NullBooleanField | 支持Null、True、False三种值 |
| CharField(max_length=最大长度) | 字符串，参数max_length表示最大字符个数 |
| TextField | 大文本字段，一般超过4000个 |
| IntegerField | 整数 |
| DecimalField(max_digits=None,decimal_place=None) | 十进制浮点数。参数max_digits表示总位。参数decimal_places表示小数位数 |
| FloatField | 浮点数。参数同上 |
| DateField:([auto_now=False,auto_now_add=False]) | 日期。1.参数auto_now表示每次保存对象时，自动设置该字段为当前时间，用于“最后一次修改”的时间戳，他总是使用当前日期，默认为false。2.参数auto_now_add表示当对象第一次被创建时自动设置当前时间，用于创建的时间戳，他总是使用当前日期，默认为false。3.参数auto_now_add 和auto_now是相互排斥的，组合将会发生错误。 |
| TimeField | 时间，参数同datefield |
| DateTimeField | 日期时间，参数同DateField |
| FileField | 上传文件字段 |
| ImageField | 继承于FileField，对上传的内容进行校验，确保是有效的图片 |
通过选项实现对字段的约束，选项如下：
| 选项名 | 描述 |
|---|---|
| default | 默认值，设置默认值 |
| primary_key | 若为True,则该字段会成为模型的主键字段，默认值为false，一般作为autofield的选项使用 |
| unique | 如果为True,这个字段在表中必须唯一值，默认值是false |
| db_index | 若值为True,则在表中会为此字段创建索引，默认值是false |
| db_column | 字段的名称，如果未指定，则使用属性的名称 |
| null | 如果为True,表示允许为空，默认值是false |
| blank | 如果为True,则该字段允许为空白，默认值是false |
vim test1/urls.py
urlpatterns =[
#通过url函数设置url路由配置项
url(r'^index$',views.index), # 建立index和视图之间的关系
url(r'^index2$',views.index2),
url(r'^books$',views.show_books), #显示图书信息
url(r'^books/(\d+)$',views.detail), #显示英雄信息
]vim views.py
def show_books(request):
'''显示图书的信息'''
#1.通过M查找图书表中的数据
books=BookInfo.objects.all()
#2.使用模板
return render(request,'test1/show_books.html',{'books':books})
def detail(request,bid):
'''查询图书关联英雄信息'''
#1.根据bid查询图书信息
book=BookInfo.objects.get(id=bid)
#2.查询和book关联的英雄信息
heros=book.heroinfo_set.all()
#3.使用模板
return render(request,'test1/detail.html',{'book':book,'heros':heros})vim templates/test1/show_books.html
<!DOCTYPE>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>显示图书信息</title>
</head>
<body>
图书信息如下：
<ul>
{% for book in books %}
<li><a href="/books/{{ book.id }}">{{ book.btitle }}</a></li>
{% endfor %}
</ul>
</body>
</html>vim detail.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>显示图书关联的英雄信息</title>
</head>
<body>
<h2>{{ book.btitle }}</h2>
英雄信息如下:<br/>
<ul>
{% for hero in heros %}
<li>{{ hero.hname }}--{{ hero.hcomment }}</li>
{% empty %}
<li>没有英雄信息</li>
{% endfor %}
</ul>
</body>
</html>vim settings.py
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'booktest', #注册应用
]
DATABASES = {
'default': {
#'ENGINE': 'django.db.backends.sqlite3',
#'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
'ENGINE': 'django.db.backends.mysql',
'NAME': 'booktest', #使用的数据库名字
'USER': 'root', #mysql用户名
'PASSWORD': 'root', #mysql密码
'HOST': 'localhost', #mysql主机
'PORT': 3306,
}
}创建数据库
create database booktest charset=utf8;安装pymysql
pip install pymysqlvim __init__.py
ALLOWED_HOSTS = ['60.205.177.168']from test1.models import BookInfo
# Register your models here.
#注册模型类
admin.site.register(BookInfo)vim models.py
class BookInfo(models.Model):
'''图书模型类'''
btitle=models.CharField(max_length=20)
#出版日期，DateField说明是一个日期类型
bpub_date=models.DateField()
def __str__(self):
#返回书名
return self.btitleclass BookInfoAdmin(admin.ModelAdmin):
'''图书模型管理类'''
list_display=['id','btitle','bpub_date']
class HeroInfoAdmin(admin.ModelAdmin):
'''英雄模型人物类'''
list_display=['id','hname','hcomment']
#注册模型类
admin.site.register(BookInfo,BookInfoAdmin)
admin.site.register(HeroInfo,HeroInfoAdmin)在Django中，通过浏览器去请求一个页面时，使用视图函数来处理这个请求的，视图函数处理之后，要给浏览器返回页面内容
返回HTML内容httpresponse，也可能重定向redirect
视图函数定义在views.py中
视图函数必须有一个参数request，是一个httprequest类型的对象，参数名可以变化，进行处理之后，需要返回一个HttpResponse的类对象，hello,python就是返回给浏览器显示的内容
例：
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
#1.定义视图函数,HttpRequest
#2.进行url配置，建立url地址和视图的对应关系
#http://127.0.0.1:8000/index
def index(request):
#进行处理，和M,T进行交互
return HttpResponse('老铁没毛病')
def index2(request):
return HttpResponse('hello python')url配置的目的是建立url和视图函数的对应关系。url配置项定义在urlpatterns的列表中，每一个配置项都调用url函数。
url函数有两个参数，第一个参数是一个正则表达式，第二个是对应的处理动作。
配置url时，有两种语法格式：
在项目的urls.py文件中包含具体应用的urls.py文件，应用的urls.py文件中写url和视图函数的对应关系
当用户输入如127.0.0.1:8000/index时，去除域名和最前面的/,剩下index，拿index字符串到项目的urls文件中进行匹配，配置成功之后，继续到项目中的urls文件中进行正则匹配，匹配成功之后执行视图函数index，index视图函数返回内容hello python 给浏览器来显示
vim /myobj/urls.py
from django.contrib import admin
#from django.urls import path
from django.conf.urls import include,url
urlpatterns = [
url(r'^admin/',admin.site.urls),#配置项
url(r'^',include('test1.urls')) #包含test1应用中的urls文件
]vim test1/urls.py
from django.conf.urls import url
from test1 import views
# /index
#在应用的urls文件中进行url配置的时候：
#1.严格匹配开头和结尾
urlpatterns =[
#通过url函数设置url路由配置项
url(r'^index$',views.index), # 建立index和视图之间的关系
url(r'^index2$',views.index2),
]404：找不到页面，关闭调试模式之后，默认会显示一个标准的错误页面，如果要显示自定义的页面，则需要templates目录下面自定义一个404.html文件
进行url匹配时，把所需要的捕获的部分设置成一个正则表达式组，这样Django框架就会自动把匹配成功后相应组的内容作为参数传递给视图函数。
from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^index$',views.index), #首页,
url(r'^showarg(\d+)$',views.show_arg), #捕获url参数
]vim test3/urls.py
urlpatterns = [
path('admin/', admin.site.urls),
url(r'^',include('booktest.urls')),
]vim booktest/views.py
from django.shortcuts import render
from django.http import HttpResponse
# Create your views here.
def index(request):
'''首页'''
return render(request,'booktest/index.html')
def show_arg(request,num):
return HttpResponse(num)from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^index$',views.index), #首页,
url(r'^showarg(\d+)$',views.show_arg), #捕获url参数：位置参数
url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕获关键字参数
]from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^index$',views.index), #首页,
url(r'^showarg(\d+)$',views.show_arg), #捕获url参数：位置参数
url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕获关键字参数
url(r'^login$',views.login), #显示登录页面
url(r'^login_check$',views.login_check),
]vim login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<form method="post" action="/login_check">
用户名:<input type="text" name="username"><br/>
密码:<input type="password" name="password"><br/>
<input type="submit" value="登录">
</form>
</body>
</html>| url | 视图 | 模板文件 |
|---|---|---|
| /login | login | login.html |
注释掉settings.py文件的47行
vim booktest/views.py
from django.shortcuts import render,redirect
from django.http import HttpResponse
# Create your views here.
def index(request):
'''首页'''
return render(request,'booktest/index.html')
def show_arg(request,num):
return HttpResponse(num)
def login(request):
'''显示登录页面'''
return render(request,'booktest/login.html')
def login_check(request):
'''登录校验视图'''
#request.POST保存的是post方式提交的参数 QueryDict
# request.GET保存的是get方式提交的参数
#1. 获取提交的用户名和密码
username=request.POST.get('username')
password=request.POST.get('password')
#2. 进行登录的校验
#实际开发：根据用户和密码查找数据库
#模拟：smart 123
if username=='smart' and password=='123':
#用户名密码正确，跳转到首页
return redirect('/index')
else:
#用户名或密码错误，跳转到登录页面
return redirect('/login')cookie是由服务器生成，存储在浏览器端的一小段文本信息
vim booktest/urls.py
from django.shortcuts import render,redirect
from django.http import HttpResponse
from datetime import datetime,timedelta
# /set_cookie
def set_cookie(request):
'''设置一个cookie信息'''
response=HttpResponse('设置cookie')
# 设置一个cookie信息，名字为num，值为1
response.set_cookie('num',1,max_age=14*24*3600)
#response.set_cookie('num', 1, expires=datetime.now()+timedelta(days=14))
#返回response
return response
# /get_cookie
def get_cookie(request):
'''获取cookie的信息'''
#取出cookie num的值
num=request.COOKIES['num']
return HttpResponse(num)vim booktest/urls.py
urlpatterns = [
url(r'^index$',views.index), #首页,
url(r'^showarg(\d+)$',views.show_arg), #捕获url参数：位置参数
url(r'^showarg(?P<num>\d+)$',views.show_arg), #捕获关键字参数
url(r'^login$',views.login), #显示登录页面
url(r'^login_check$',views.login_check),
url(r'^set_cookie$',views.set_cookie), #设置cookie
url(r'^get_cookie$',views.get_cookie), #获取cookie
]vim login.html
<form method="post" action="/login_check">
用户名:<input type="text" name="username" value="{{ username }}"><br/>
密码:<input type="password" name="password"><br/>
<input type="checkbox" name="remember">记住用户名<br/>
<input type="submit" value="登录">
</form>vim booktest/views.py
def login(request):
'''显示登录页面'''
#获取cookie username
if 'username' in request.COOKIES:
#获取记住的用户名
username = request.COOKIES['username']
else:
username=''
return render(request,'booktest/login.html',{'username':username})
def login_check(request):
'''登录校验视图'''
#request.POST保存的是post方式提交的参数 QueryDict
# request.GET保存的是get方式提交的参数
#1. 获取提交的用户名和密码
username=request.POST.get('username')
password=request.POST.get('password')
remember=request.POST.get('remember')
#2. 进行登录的校验
#实际开发：根据用户和密码查找数据库
#模拟：smart 123
if username=='smart' and password=='123':
#用户名密码正确，跳转到首页
response=redirect('/index')
#判断是否需要记住用户名
if remember == 'on':
#设置cookie username，过期时间为一周
response.set_cookie('username',username,max_age=7*24*3600)
return response
else:
#用户名或密码错误，跳转到登录页面
return redirect('/login')session存储在服务器端
vim booktest/views.py
#/set_session
def set_session(request):
'''设置session'''
request.session['username']='smart'
request.session['age']=18
return HttpResponse('设置session')
#/get_session
def get_session(request):
'''获取session'''
username=request.session['username']
age=request.session['age']
return HttpResponse(username+':'+str(age))
#/clear_session
def clear_session(request):
'''清除session信息'''
#request.session.clear()
request.session.flush()
#del request.session['age']
return HttpResponse('清除成功') vim booktest/urls.py
url(r'^set_session$',views.set_session), #设置session
url(r'^get_session$',views.get_session), #获取session
url(r'^clear_session$',views.clear_session), #清除session如果没有指定过期时间则两个星期后过期request.sesion.set_expiry(value)
vim views.py
def login(request):
'''显示登录页面'''
#判断用户是否登录
if request.session.has_key('islogin'):
return redirect('/index')
else:
#用户未登录
#获取cookie username
if 'username' in request.COOKIES:
#获取记住的用户名
username = request.COOKIES['username']
else:
username=''
return render(request,'booktest/login.html',{'username':username})
def login_check(request):
'''登录校验视图'''
#request.POST保存的是post方式提交的参数 QueryDict
# request.GET保存的是get方式提交的参数
#1. 获取提交的用户名和密码
username=request.POST.get('username')
password=request.POST.get('password')
remember=request.POST.get('remember')
#2. 进行登录的校验
#实际开发：根据用户和密码查找数据库
#模拟：smart 123
if username=='smart' and password=='123':
#用户名密码正确，跳转到首页
response=redirect('/index')
#判断是否需要记住用户名
if remember == 'on':
#设置cookie username，过期时间为一周
response.set_cookie('username',username,max_age=7*24*3600)
#记住用户登录状态
#只有session中有islogin，就认为用户已登录
request.session['islogin']=True
return response
else:
#用户名或密码错误，跳转到登录页面
return redirect('/login')通常是在视图函数中使用模板产生html内容返回给客户端
'DIRS': [os.path.join(BASE_DIR,'templates')],django.template.loaders.filesystem.Loader：/root/wanger/test4/templates/booktest/index2.html（来源不存在）
django.template.loaders.app_directories.Loader：/root/.virtualenvs/wanger/lib/python3.5/site-packages/django/contrib/admin/templates/booktest/index2.html（来源不存在）
django.template.loaders.app_directories.Loader：/root/.virtualenvs/wanger/lib/python3.5/site-packages/django/contrib/auth/templates/booktest/index2.html（来源不存在）模板语言简称为DTL（Django template language）
模板变量名是由数字，字母，下划线和点组成的，不能以下划线开头
模板变量使用：{{ 模板变量名 }}
模板变量的解析顺序:
例如：{{ book.btitle }}
把book当成一个对象，把btitle当成对象的方法，进行取值book.btitle
例如：{{book.0}}
from django.db import models
# Create your models here.
class BookInfo(models.Model):
'''图书模型类'''
#图书名称
btitle=models.CharField(max_length=20,db_column='btitle')
#出版日期
bpub_date=models.DateField()
#阅读量
bread=models.IntegerField(default=0)
#评论量
bcomment=models.IntegerField(default=0)
#删除标记
isdelete=models.BooleanField(default=False)vim views.py
from booktest.models import BookInfo
# /temp_var
def temp_var(request):
'''模板变量'''
my_dict={'title':'字典键值'}
my_list=[1,2,3]
book=BookInfo.objects.get(id=1)
#定义模板上下文
context={'my_dict':my_dict,'my_list':my_list,'book':book}
return render(request,'booktest/temp_var.html',context)vim urls.py
from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^temp_var$',views.temp_var),#模板变量
]vim temp_var.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>模板变量</title>
</head>
<body>
使用字典属性:{{ my_dict.title }}<br/>
使用列表元素:{{ my_list.1 }}<br/>
使用对象属性:{{ book.btitle }}<br/>
</body>
</html>模板代码段：{% 代码段 %}
for循环：
{% for i in list %}列表不为空时执行
{% empty %}列表为空时执行
{% endfor %}可以通过{{ forloop.counter }}得到for循环遍历到了第几次
vim urls.py
from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^temp_tags$',views.temp_tags),
]vim views.py
# /temp_tags
def temp_tags(request):
'''模板标签'''
#1. 查找所有图书的信息
books=BookInfo.objects.all()
return render(request,'booktest/temp_tags.html',{'books':books})vim temp_tags.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>模板标签</title>
</head>
<body>
<ul>
{% for book in books %}
<li>{{ forlop.counter }}--{{ book.btitle }}</li>
{% endfor %}
</ul>
</body>
</html>{% if 条件 %}
{% elif 条件 %}
{% else %}
{% endif %}关系比较操作符：< > <= >= !=
注意:进行比较时，比较操作符两边必须有空格
逻辑运算：not and or
vim temp_tags.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>模板标签</title>
<style>
.red {
background-color: red;
}
.yellow {
background-color: yellow;
}
.green {
background-color: green;
}
</style>
</head>
<body>
<ul>
{% for book in books %}
{% if book.id <= 2 %}
<li class="red">{{ forloop.counter }}--{{ book.btitle }}</li>
{% elif book.id <= 4 %}
<li class="yellow">{{ forloop.counter }}--{{ book.btitle }}</li>
{% else %}
<li class="green">{{ forloop.counter }}--{{ book.btitle }}</li>
{% endif %}
{% endfor %}
</ul>
</body>
</html>过滤器用于对模板变量进行操作
date:改变日期的显示格式
length：求长度。字符串，列表长度
default:设置模板变量的默认值
格式：模板变量|过滤器：参数
自定义过滤器。
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>模板过滤器</title>
<style>
.red {
background-color: red;
}
.green {
background-color: green;
}
</style>
</head>
<body>
<ul>
{% for book in books %}
{% if book.id <= 2 %}
<li class="red">{{ book.btitle }}--{{ book.bpub_date|date:'Y年-m月-d日' }}</li>
{% else %}
<li class="green">{{ book.btitle }}--{{ book.bpub_date }}</li>
{% endif %}
{% endfor %}
</ul>
default过滤器：<br/>
{{ content|default:'hello' }}
</body>
</html>在应用下创建一个包templatetags，包的名字固定，在包下创建一个过滤器文件vim filters.py
#自定义过滤器
#过滤器其实就是python函数
from django.template import Library
#创建一个library类的对象
register=Library()
#自定义的过滤器函数，最少有一个参数，最多有两个
@register.filter
def mod(num):
'''判断num是否为偶数'''
return num%2 == 0
@register.filter
def mod_val(num,val):
'''判断num是否能被val整除'''
return num%val ==0vim temp_filters.html
<!DOCTYPE html>
<html lang="en">
{% load filters %}
<head>
<meta charset="UTF-8">
<title>模板过滤器</title>
<style>
.red {
background-color: red;
}
.green {
background-color: green;
}
</style>
</head>
<body>
<ul>
{% for book in books %}
{# {% if book.id <= 2 %} #}
{# {% if book.id|mod %} #}
{% if book.id|mod_val:3 %}
<li class="red">{{ book.id }}--{{ book.btitle }}--{{ book.bpub_date|date:'Y年-m月-d日' }}</li>
{% else %}
<li class="green">{{ book.btitle }}--{{ book.bpub_date }}</li>
{% endif %}
{% endfor %}
</ul>
default过滤器：<br/>
{{ content|default:'hello' }}
</body>
</html>单行注释：{# 注释内容 #}
多行注释：{% comment %}
注释内容
{% endcomment %}
把所有页面相同的内容放到父模板文件中，不需要放在块中，有些位置页面内容不同，需要在父模板中预留块。
在父模板里可以定义块，使用标签：{% block 块名 %}
块中间可以写内容，也可以不写{% endblock 块名 %}
字模板去继承父模板之后，可以重写父模板中的某一块内容
继承格式：
{% extends 父模板文件路径 %}
{% block 块名 %}
{{ block.super }} #获取父模板中块的默认内容
重写的内容
{% endblock 块名 %}vim views.py
#/temp_inherit
def temp_inherit(request):
'''模板继承'''
return render(request,'booktest/child.html')vim base.html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>父模板文件</title>
</head>
<body>
<h2>导航条</h2>
{% block b1 %}
<h2>这是父模板b1块中</h2>
{% endblock b1 %}
<h2>版权信息</h2>
</body>
</html>vim child.html
{% extends 'booktest/base.html' %}
{% block b1 %}
{{ block.super }}
<b1>这是子模板b1块中的内容</b1>
{% endblock b1 %}vim urls.py
url(r'^temp_inherit$',views.temp_inherit), ##模板继承编辑商品详情信息，数据表中保存的是html内容
在模板上下文中的html标记默认是会被转义的
< 转化为& lt;
> 转换为& gt;
' 转换为& #39;
" 转换为& quot;
& 转换为& amp;要关闭模板上下文字符串的转义：可以使用{{ 模板变量|safe }}
也可以使用
{% autoescape off %}
模板语言代码
{% endautoescape %}
模板硬编码中的字符串默认不会经过转义，如果需要转义，那需要手动进行转义
vim views.py
def html_escape(request):
'''HTML转义'''
return render(request,'booktest/html_escape.html',{'content':'<h2>hello</h2>'})vim urls.py
url(r'^html_escape$',views.html_escape), #HTML转义vim html_escap[e.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>html转义</title>
</head>
<body>
{{ content }}
使用safe过滤器关闭转义：<br/>
{{ content|safe }}
</br>
模板硬编码中的字符串不会经过转义<br/>
{{ test|default:'<h2>hello</h2>' }}<br/>
手动进行转义：<br/>
{{ test|default:'<h2>hello</h2>' }}
</body>
</html>首先做一个登录页，让用户输入用户名和密码进行登录，登陆成功之后跳转的修改密码页面。在修改密码页面输入新密码，点击确认按钮完成密码修改
登录页需要一个模板文件login.html，修改密码页面也需要一个模板文件
change_pwd.html
显示登录页的视图login，验证登录的视图login_check，显示发帖页的视图change_pwd，处理修改密码的视图change_pwd_action
加功能：
vim views.py
def login_required(view_func):
'''登录判断装饰器'''
def wrapper(request,*views_args,**view_kwargs):
#判断用户是否登录
if request.session.has_key('islogin'):
#用户已登录，调用对应的视图
return view_func(request,*views_args,**view_kwargs)
else:
#用户未登录，跳转到登录页
return redirect('/login')
return wrapper
def login(request):
'''显示登录页面'''
#判断用户是否登录
if request.session.has_key('islogin'):
return redirect('/index')
else:
#用户未登录
#获取cookie username
if 'username' in request.COOKIES:
#获取记住的用户名
username = request.COOKIES['username']
else:
username=''
return render(request,'booktest/login.html',{'username':username})
def login_check(request):
'''登录校验视图'''
username=request.POST.get('username')
password=request.POST.get('password')
remember=request.POST.get('remember')
#2. 进行登录的校验
#实际开发：根据用户和密码查找数据库
#模拟：smart 123
if username=='smart' and password=='123':
#用户名密码正确，跳转到首页
response=redirect('/index')
#判断是否需要记住用户名
if remember == 'on':
#设置cookie username，过期时间为一周
response.set_cookie('username',username,max_age=7*24*3600)
#记住用户登录状态
#只有session中有islogin，就认为用户已登录
request.session['islogin']=True
#记住登录的用户名
request.session['username']=username
return response
else:
#用户名或密码错误，跳转到登录页面
request.session['username']=username
return redirect('/change_pwd')
# /change_pwd
@login_required
def change_pwd(request):
'''显示修改密码页面'''
return render(request,'booktest/change_pwd.html')
# /change_pwd_action
@login_required
def change_pwd_action(request):
'''模拟修改密码处理'''
# 1.获取新密码
pwd=request.POST.get('pwd')
#获取用户名
username=request.session.get('username')
#2.实际开发的时候:修改对应数据库的内容
#3.返回一个应答
return HttpResponse('%s修改密码为:%s' %(username,pwd))vim urls.py
url(r'^login$',views.login), #显示登录页面
url(r'^login_check$',views.login_check), #进行登录校验
url(r'^change_pwd$',views.change_pwd), #修改密码页面显示
url(r'^change_pwd_action$',views.change_pwd_action), #修改密码处理vim login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<form method="post" action="/login_check">
用户名:<input type="text" name="username" value="{{ username }}"><br/>
密码:<input type="password" name="password"><br/>
<input type="checkbox" name="remember">记住用户名<br/>
<input type="submit" value="登录">
</form>
</body>
</html>vim change_pwd.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>修改密码界面</title>
</head>
<body>
<form method="post" action="/change_pwd_action">
新密码:<input type="password" name="pwd">
<input type="submit" value="确认修改">
</form>
</body>
</html>防御原理：
vim views.py
def login_check(request):
'''登录校验视图'''
username=request.POST.get('username')
password=request.POST.get('password')
remember=request.POST.get('remember')
#获取用户输入验证码
vcode1=request.POST.get('vcode')
#获取session中保存的验证码
vcode2=request.session.get('verifycode')
#进行验证码校验
if vcode1 != vcode2:
#验证码错误
return redirect('/login')
#2. 进行登录的校验
#实际开发：根据用户和密码查找数据库
#模拟：smart 123
if username=='smart' and password=='123':
#用户名密码正确，跳转到首页
response=redirect('/index')
#判断是否需要记住用户名
...
#/验证码
from PIL import Image,ImageDraw,ImageFont
from django.utils.six import BytesIO
def verify_code(request):
#引入随机函数模块
import random
#定义变量，用于画面的背景色、宽、高
bgcolor=(random.randrange(20,100),random.randrange(20,100),255)
width=100
height=25
#构建画面图像
im=Image.new('RGB',(width,height),bgcolor)
#创建画笔对象
draw=ImageDraw.Draw(im)
#调用画笔的point()函数绘制噪点
for i in range(0,100):
xy=(random.randrange(0,width),random.randrange(0,height))
fill=(random.randrange(0,255),255,random.randrange(0,255))
draw.point(xy,fill=fill)
#定义验证码的备选值
str1='ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890'
#随机选取4个值作为验证码
rand_str=''
for i in range(0,4):
rand_str+=str1[random.randrange(0,len(str1))]
#构造字体对象
font=ImageFont.truetype('/usr/share/fonts/gnu-free/FreeMonoBold.ttf',23)
#构造字体的颜色
fontcolor=(255,random.randrange(0,255),random.randrange(0,255))
#绘制四个字
draw.text((5,2),rand_str[0],font=font,fill=fontcolor)
draw.text((25,2),rand_str[1],font=font,fill=fontcolor)
draw.text((50, 2), rand_str[2], font=font, fill=fontcolor)
draw.text((75, 2), rand_str[3], font=font, fill=fontcolor)
#释放画笔
del draw
#存入session，用于做进一步验证
request.session['verifycode']=rand_str
#内存文件操作
buf=BytesIO()
#将图片保存在内存中，文件类型是png
im.save(buf,'png')
#将内存中的图片数据返回给客户端，mime类型为图片png
return HttpResponse(buf.getvalue(),'image/png')vim login.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
<form method="post" action="/login_check">
{% csrf_token %}
用户名:<input type="text" name="username" value="{{ username }}"><br/>
密码:<input type="password" name="password"><br/>
<input type="checkbox" name="remember">记住用户名<br/>
<img src="/verify_code"><input type="text" name="vcode"><br/>
<input type="submit" value="登录">
</form>
</body>
</html>当某一个url配置的地址发生变化时，页面上使用反向解析生成地址的位置不需要发生变化
根据url正则表达式的配置动态的生成url
vim booktest/views.py
url(r'^url_reverse$',viewa.url_reverse), #反向解析页面vim models.py
from django.db import models
# Create your models here.
class BookInfo(models.Model):
'''图书模型类'''
#图书名称
btitle=models.CharField(max_length=20)
#出版日期
bpub_date=models.DateField()
#阅读量
bread=models.IntegerField(default=0)
#评论量
bcomment=models.IntegerField(default=0)
#删除标记
isdelete=models.BooleanField(default=False)
class HeroInfo(models.Model):
'''英雄人物模型类'''
#英雄名
hname=models.CharField(max_length=20)
#性别
hgender=models.BooleanField(default=False)
#备注
hcomment=models.CharField(max_length=200)
#关系属性
hbook=models.ForeignKey('BookInfo',on_delete=models.CASCADE,)
# 删除标记
isdelete=models.BooleanField(default=False)执行迁移文件生成表
python manage.py makemigrations
python manage.py migrate往数据表里插入数据
insert into booktest_bookinfo(btitle,bpub_date,bread,bcomment,isdelete) values
-> ('射雕英雄传','1980-5-1',12,34,0),
-> ('天龙八部','1986-7-24',36,40,0),
-> ('笑傲江湖','1995-12-24',20,80,0),
-> ('雪山飞狐','1987-11-11',58,24,0);
insert into booktest_heroinfo(hname,hgender,hbook_id,hcomment,isdelete) valu s 掌0) ('郭靖',1,1,'降龙十八掌',0), ('黄蓉',0,1,'打狗棍法',0), ('黄药师',1,1,'弹指神 姐姐 ('欧阳锋',1,1,'蛤蟆功',0), ('梅超风',0,1,'九阴白骨爪',0) ,('乔峰',1,2,'降龙十 剑法',0), ('段誉',1,2,'六脉神剑',0), ('虚竹',1,2,'天山折梅手',0), ('王语嫣',0,2,'神 黄衣',,0), ('令狐冲',1,3,'独孤九剑',0), ('任盈盈',0,3,'弹琴',0), ('岳不群',1,3,'华.剑Query OK, 17 rows affected (0.00 sec)), ('胡斐',1,4,'胡家刀法',0), ('苗春兰',0,4,'黄衣Records: 17 Duplicates: 0 Warnings: 00,4,'六合拳',0);vim index.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>图书信息</title>
</head>
<body>
<a href="/create">新增</a>
<ul>
{% for book in books %}
<li>{{ book.btitle }}--<a href="/delete{{ book.id }}">删除</a></li>
{% endfor %}
</ul>
</body>
</html>vim booktest/views.py
from django.shortcuts import render,redirect
from booktest.models import BookInfo
from datetime import date
from django.http import HttpResponse,HttpResponseRedirect
# Create your views here.
def index(request):
'''显示图书信息'''
#1. 查询出所有图书的信息
books=BookInfo.objects.all()
#2.使用模板
return render(request,'booktest/index.html',{'books':books})
def create(request):
'''新增一本图书'''
#1.创建BookInfo对象
b=BookInfo()
b.btitle='流星蝴蝶剑'
b.bpub_date=date(1990,1,1)
#2.保存进数据库
b.save()
#3.返回应答，让浏览器再访问/index
return HttpResponse('ok')
#return HttpResponseRedirect('/index')
def delete(request,bid):
'''删除点击的图书'''
#1.通过bid获取图书对象
book=BookInfo.objects.get(id=bid)
#2.删除
book.delete()
#3.重定向，让浏览器访问/index
#return HttpResponseRedirect('/index')
return redirect('/index')vim test2/urls.py
from django.contrib import admin
#from django.urls import path
from django.conf.urls import include,url
urlpatterns = [
url(r'^admin/',admin.site.urls),#配置项
url(r'^',include('booktest.urls')) #包含test1应用中的urls文件
]vim booktest/urls.py
from django.conf.urls import url
from booktest import views
urlpatterns=[
url(r'^index$',views.index), #图书信息页面
url(r'^create$',views.create), #添加图书信息
url(r'^delete(\d+)$',views.delete), #删除点击的图书
]修改mysql的日志文件：
让其产生mysql.log，即是mysql的日志文件，里面记录的对mysql数据库的操作记录
general_log=1 general_log_file= /usr/local/mysql/data/mysql.log，然后保存vi /etc/my.cnfmysql.server starttail /usr/local/mysql/data/mysql.log通过模型类.objects属性可以调用如下函数，实现对模型类对应的数据表的查询
| 函数名 | 功能 | 返回值 | 说明 |
|---|---|---|---|
| get | 返回表中满足条件的一条且只能有一条数据 | 返回值是一个模型类对象 | 参数中写查询条件 1.如果查到多条数据，则抛异常multipleobjectreturned。2.查询不到数据，则抛异常:doesnotexist |
| all | 返回模型类对应表格中的所有数据 | 返回值是queryset类型 | 查询集 |
| filter | 返回满足条件的数据 | 返回值是queryset类型 | 参数写查询条件 |
| exclude | 返回不满足条件的数据 | 返回值是queryset类型 | 参数写查询条件 |
| order_by | 对查询结果进行排序 | 返回值是queryset类型 | 参数中写根据哪些字段进行排序 |
作用：用于查询时条件之间的逻辑关系。mot and or，可以对Q对象进行&|~操作
使用之前需要先导入：from Django.db.models import Q
例：查询id大于3且阅读量大于30的图书的信息BookInfo.objects.filter(id__gt=3,bread__gt=30)BookInfo.objects.filter(Q(id__gt=3)&Q(bread__gt=30))
例：查询id大于3或者阅读量大于30的图书的信息BookInfo.objects.filter(Q(id__gt=3)|Q(bread__gt=30))
例：查询id不等于3图书的信息BookInfo.objects.filter(~Q(id=3))
作用：用于类属性之间的比较
使用之前需要先导入：from django.db.models import F
例：查询图书阅读量大于评论量图书的信息BookInfo.objects.filter(bread__gt=F('bcomment'))
例：查询图书阅读量大于2倍评论量图书信息BookInfo.objects.filter(bread__gt=F('bcomment')*2)
作用：对查询结果进行聚合操作
sum count avg max min
aggregate：调用这个函数来使用聚合。返回值是一个字典。
使用前需先导入聚合类：from django.db.models import Sum,Count,Max,Min,Avg
例：查询所有图书的数目
select count(*) from booktest_bookinfo;
BookInfo.objects.all().aggregate(Count('id'))
BookInfo.objects.aggregate(Count('id'))例：查询所有图书阅读量的总和BookInfo.objects.aggregate(Sum('bread'))
all,filter,exclude,order_by调用这些函数会产生一个查询集
QuerySet类对象可以继续调用上面的所有函数
可以对一个查询集进行取下标或者切片操作来限制查询集的结果
对一个查询集进行切片操作会产生一个新的查询集，下标不允许为负数。
取出查询集第一条数据的两种方式：
| 方式 | 说明 |
|---|---|
| b[0] | 如果b[0]不存在，会抛出IndexError异常 |
| b[0:1].get() | 如果b[0:1].get()不存在，会抛出DoesNotExist异常 |
models.ForeignKey()定义多的类中
models.ManyToManyField()定义在哪个类中都可以models.OneToOneField定义在哪个类中都可以在一对多关系中，一对应的类我们把他叫做一类，多对应的类我们把它叫做多类，我们把多类中定义的建立关联的类属性叫做关联属性。
例：查询id为1的图书关联的英雄的信息。
b=BookInfo.objects.get(id=1)
b.heroinfo_set.all()通过模型类查询：HeroInfo.objects.filter(hbook__id=1)
例：查询id为1的英雄关联的图书信息
h=HeroInfo.objects.get(id=1)
h.hbook()通过模型类查询：BookInfo.objects.filter(heroinfo__id=1)
自关联是一种特殊的一对多的关系
BookInfo.objects.all()->ojects是一个什么东西呢？
答：
class BookInfoManager(models.Manager):
'''图书模型管理器类'''
# 1.改变查询的结果集
def all(self):
#1.调用父类的all，获取所有数据
books=super().all() #QuerySet
#2. 对数据进行过滤
books=books.filter(isDelete=False)
#3.返回books
return books
#2.封装函数：操作模型类对应的数据表(增删改查)
def create_book(self,btitle,bpub_date):
#1.创建一个图书对象
model_class=self.model
book=model_class()
#book=BookInfo()
book.btitle=btitle
book.bpub_date=bpub_date
#2.保存进数据库
book.save()
#3.返回book
return book class BookInfo(models.Model):
class Meta:
db_table='bookinfo'在网页使用的css文件，js文件和图片叫做静态文件
vim settings.py
#设置访问静态文件对应的url地址
STATIC_URL = '/static/'
#设置静态文件存放的物理目录
STATICFILES_DIRS=[os.path.join(BASE_DIR,'static')]vim static_test.html
<!DOCTYPE html>
{% load staticfiles %}
<html lang="en">
<head>
<meta charset="UTF-8">
<title>静态文件</title>
</head>
<body>
<img src="/static/images/mm.jpg"><br/>
动态获取STATIC_URL，拼接静态文件路径:<br/>
<img src="{% static 'images/mm.jpg' %}">
</body>
</html>vim views.py
from django.shortcuts import render
from django.conf import settings
# Create your views here.
# /static_test
def static_test(request):
'''静态文件'''
print(settings.STATICFILES_FINDERS)
return render(request,'booktest/static_test.html')vim urls.py
from django.conf.urls import url
from booktest import views
urlpatterns = [
url(r'^static_test$',views.static_test), #静态文件
]STATICFILES_FINDERS=('django.contrib.staticfiles.finders.FileSystemFinder','django.contrib.staticfiles.finders.AppDirectoriesFinder')中间件函数是Django框架给我们预留的函数接口，让我们可以干预请求和应答的过程
使用request对象的meta属性：request.META['REMOTE_ADDR']
vim booktest/middleware.py
如果注册的多个中间件类中包含process_exception函数的时候，调用的顺序跟注册的顺序是相反的
vim booktest/middleware.py
from django.http import HttpResponse
from django.utils.deprecation import MiddlewareMixin
class BlockedIPSMiddleware(object):
EXCLUDE_IPS=['223.71.207.106']
def process_view(self,request,view_func,*view_arg,**view_kwargs):
'''视图函数调用之前会调用'''
user_ip=request.META['REMOTE_ADDR']
if user_ip in BlockedIPSMiddleware.EXCLUDE_IPS:
return HttpResponse('<h2>Forbidden</h2>')vim settings.py
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',
'booktest.middleware.BlockedIPSMiddleware', #注册中间件类
]#设置上传文件的保存目录
MEDIA_ROOT=os.path.join(BASE_DIR,'static/media')vim models.py
from django.db import models
# Create your models here.
class PicTest(models.Model):
'''上传图片''' goods_pic=models.ImageField(upload_to='booktest')python manage.py makimigrations
python manage.py migrate
vim admin.py
from django.contrib import admin
from booktest.models import PicTest
admin.site.register(PicTest)vim upload_pic.html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>上传图片</title>
</head>
<body>
<form method="post" enctype="multipart/form-data" action="upload_handle">
{% csrf_token %}
<input type="file" name="pic"><br/>
<input type="submit" value="上传">
</form>
</body>
</html>vim views.py
from booktest.models import PicTest
def show_upload(request):
'''显示上传图片页面'''
return render(request,'booktest/upload_pic.html')
def upload_handle(request):
'''上传图片处理'''
# 1.获取上传的图片
pic =request.FILES['pic']
#print (pic.name)
#2.创建一个文件
save_path= '%s/booktest/%s' %(settings.MEDIA_ROOT,pic.name)
with open(save_path,'wb') as f:
#3.获取上传文件的内容并写到创建的文件中
for content in pic.chunks():
f.write(content)
#4. 在数据库中保存上传记录
PicTest.objects.create(goods_pic='booktest/%s' %pic.name)
#5.返回
return HttpResponse('ok')上传文件不大于2.5M，文件放在内存中
上传文件大于2.5M，文件内容写到一个临时文件中
查询出所有省级地区的信息，显示在页面上。AreaInfo.objects.filter(aparent_isnull)
from django.core.paginator import Paginator
paginator=Paginator(areas,10) #按每页10条数据进行分页Paginator类对象的属性
| 属性名 | 说明 |
|---|---|
| num_pages | 返回分页之后的总页数 |
| page_range | 返回分页页码的列表 |
Paginator
| 方法名 | 说明 |
|---|---|
| page(self,number) | 返回第number页的page类实例对象 |
Page类对象的属性
| 属性名 | 说明 |
|---|---|
| number | 返回当前页的页码 |
| object_list | 返回包含当前页的数据的查询 |
| paginator | 返回对应的Paginator类对象 |
Page类对象的方法
| 属性名 | 说明 |
|---|---|
| has_previous | 判断当前页是否有前一页 |
| has_next | 判断当前页是否有下一页 |
| previous_page_number | 返回前一页的页码 |
| next_page_number | 返回下一页的页码 |
免责声明：本站发布的内容（图片、视频和文字）以原创、转载和分享为主，文章观点不代表本网站立场，如果涉及侵权请联系站长邮箱：is@yisu.com进行举报，并提供相关证据，一经查实，将立刻删除涉嫌侵权内容。
