django框架学习

1. Django中ajax的应用
（1）models 控件（映射数据库）
以 省、市字典为例创建模型，也可以创建一个模型（增加type列，表示当前这一行是哪种字典）
ProvinceModel
省code
省name
CityModel
市code
市name
隶属于哪个省级单位（proCode）

（2）forms 控件（配合model的数据查询）
读取model中的数据
如何同步的读取（字典model发生了变化，同步到form也能一起发生变化）


2. 二级联动
【**】任何软件系统都应该包含一个数据字典
操作系统的数据字典——注册表
（3）存储数据（数据字典——应用系统，又称为软件 中使用的所有选项的集合）
选项：固定的，例如：男、女（选择的）

【类比】：人类字典：新华字典，人类在汉语言系统中使用的所有字的集合
现代汉语辞典，人类在汉语言系统中使用的所有词的集合

【总结】：
技术和技术的组合使用
（1）model 映射模型（操作数据表）
数据初始化：pandas的read_excel，将excel的数据转存到数据库
（2）forms 表单：choices=models 从数据库中获取页面使用的选项（option）
（3）html页面，绘制select下拉框{{obj.form属性名}}
（4）javascript技术：addEventListener 添加事件监听（change）
当选项发生变化的时候，触发事件

（5）ajax技术（异步根据province请求city数据）（6）json传递技术
csrfmiddlewaretoken 获取 跨域码

在返回的数据中，仍然使用 javascript技术
getElementById 获取控件
removeChild 删除旧的选项

createElement 创建新选项
appendChild 将新选项追加到原来的city下拉框中


3. 如果字典项，在软件运行的过程中，会发生变化
此时使用 构造函数 进行数据字典的加载（降低效率）—— 字典项不需要维护不要加在构造方法中

args = arguments 表示非字典类型参数
super 调用了父类的构造方法

def __init__(self, *args, **kwargs) :
# super(类型, 对象).__init__(*args, **kwargs)
super(class当前类, self).__init__(*args, **kwargs)

# self.属性['属性名'].选项s = 模型.objects.filter(条件).values("作为key的列", "作为value的列")
self.城市.choices = models.城市模型.objects.filter(....)

4. 使用 models.模型.objects() 先获取对象
再根据其他条件，进行筛选
list = models.模型.objects().filter(过滤)
list = list.filter(再过滤)

models.模型.bulk_create(多条model) 批量

__exact 精确
__contains 模糊

字符串的过滤
models.模型.objects.filter(列__startswith=值)
models.模型.objects.filter(列__endswith=值)

聚合函数：
models.模型.objects.aggregate(AVG(列))
sum求和
count统计个数
max 最大
min 最小
avg 平均

views.py:

from django.shortcuts import render, HttpResponse
from django.http import JsonResponse
import pandas as pd
from myApp01 import models, forms

# Create your views here.
def index(request):
	if request.method == "GET":
		return render(request, "index.html")

def initDict(request):
	if request.method == "POST":
		uploadFile = request.FILES.get("myFile")
		df = pd.read_excel(uploadFile)

		for index,row in df.iterrows():
			if row['type'] == "prv":
				# 如果是省份：
				prvObj = models.ProvinceModel(prvCode=row['code'], prvName=row['name'])
				prvObj.save()
			else:
				cityObj = models.CityModel(
					cityCode=row['code'], 
					cityName=row['name'], 
					belongToPrv=row['belongTo'])
				cityObj.save()

		return HttpResponse("success")

	# 调用 initDict 的 get 方式，进入页面
	elif request.method == "GET":
		frmObj = forms.NormalForm()
		ctx = {"obj": frmObj}
		return render(request, "dict.html", context=ctx)

def ajaxLoadCity(request):
	if request.method == "POST":
		prvCode = request.POST.get("prvCode")
		
		# 当选择了特定的省份，直接查询数据库（city表）
		dictList = models.CityModel.objects.filter(belongToPrv=prvCode).values_list("cityCode", "cityName")
		
		# 在服务端先将数据转化为 json 格式
		jsonList = []	# 标准线性表，而非 model 线性表
		for city in dictList:
			jsonList.append(city)

		# safe 不检查json格式
		return JsonResponse(jsonList, safe=False)

# 模型方法完善
# 使用 城市 表作为查询目标
def modelOperate(request):
	if request.method == "GET":
		return render(request, "modelOperate.html") 
	elif request.method == "POST":
		ccs = request.POST.get("cityCodeSelect")
		cityCode = request.POST.get("cityCode")
		cns = request.POST.get("cityNameSelect")
		cityName = request.POST.get("cityName")
		btps = request.POST.get("belongToPrvSelect")
		belongToPrv = request.POST.get("belongToPrv")

		# 先获取到 model 给定的对应的对象（数据库表）
		cityObj = models.CityModel.objects
		cityList = None
		if ccs == "all":
			# 如果第一个选项就是通配（选择全部的）
			# 此处不过滤，只是获取 model 的对象
			cityList = cityObj
		elif ccs == "gt":
			cityList = cityObj.filter(cityCode__gt=cityCode)
		elif ccs == "lt":
			cityList = cityObj.filter(cityCode__lt=cityCode)
		else :
			cityList = cityObj.filter(cityCode__exact=cityCode)

		# 再已经处理过的List上，再进行一次处理
		if cns == "all":
			pass
		elif cns == "exact":
			cityList = cityList.filter(cityName__exact=cityName)
		elif cns == "contains" :
			cityList = cityList.filter(cityName__contains=cityName)
		elif cns == "starts":
			cityList = cityList.filter(cityName__startswith=cityName)
		else: # ends
			cityList = cityList.filter(cityName__endswith=cityName) 

		# 再处理隶属于的省份信息
		if btps == "all":
			pass
		elif btps == "gt":
			cityList = cityList.filter(belongToPrv__gt=belongToPrv)
		elif btps == "lt":
			cityList = cityList.filter(belongToPrv__lt=belongToPrv)
		else:
			cityList = cityList.filter(belongToPrv__exact=belongToPrv)

		# 如果所有条件都未选择，使用 all 查询全部数据
		if ccs == "all" and cns == "all" and btps == "all":
 			cityList = cityList.all()

		ctx = {"cityList": cityList}

		return render(request, "show.html", context=ctx)

forms.py :

from django import forms
from django.forms import fields
from django.forms import widgets
from myApp01 import models

class NormalForm(forms.Form):
	choicePrv = fields.ChoiceField(
		label="选择省份",
		choices=models.ProvinceModel.objects.all().values_list("prvCode", "prvName"),
		widget=widgets.Select
	)

	choiceCity = fields.ChoiceField(
		label="选择城市",
		choices=models.CityModel.objects.filter(belongToPrv=101).values_list("cityCode", "cityName"),
		widget=widgets.Select
	)

	# 如果 字典项会变化，如何使 forms 具有动态同步数据库的能力
	def __init__ (self, *args, **kwargs):
		# 在子类中，调用父类的构造方法
		super(NormalForm, self).__init__(*args, **kwargs)

		# 每次构造 NormalForm 对象时，就查询一次数据库（对数据库的数据进行动态的更新）
		self.fields['choicePrv'].choices=models.ProvinceModel.objects.all().values_list("prvCode", "prvName")

		# 如果涉及第1个省级字典项，增加城市，页面没有直接获取到新的city选项
		self.fields['choiceCity'].choices=models.CityModel.objects.filter(belongToPrv=101).values_list("cityCode", "cityName")