关于orm 的基础3 day67
day67 ORM 特殊的语法
一个简单的语法 --翻译成--> SQL语句 语法：
1. 操作数据库表 创建表、删除表、修改表 2. 操作数据库行 增、删、改、查 怎么连数据库：
需要手动创建数据库
手写一段代码
告诉Django连哪个数据库
告诉Django用pymysql代替默认的MySQLdb
发命令：
python manage.py makemigrations
python manage.py migrate 总结详细步骤：
1. 手动创建数据库
2. 在app/models.py里面写上一个类,必须继承models.Model这个类 （注意启动Django项目）
3. 在Django 项目的settings.py 里面 配置上数据库的相关信息
4. 在Django项目里的__init__.py里面写上 两句话 import pymysql pymysql.install_as_MySQLdb()
5. 给Django发布命令
1. python manage.py makemigrations # 相当于去你的models.py 里面看一下有没有改动
2. python manage.py migrate # 把改动翻译成SQL语句，然后去数据库执行 models.py --> Django翻译成SQL --> pymysql --> MySQL(4p) 哪吒老师ORM思想：
五步四部分 目前为止学到的特殊语法之操作数据表部分：
1. 通过建一个类（继承models.Model） --> 相当于创建了一个数据库中的表 --> 类 - 数据表
2. 字段：
1. models.AutoField(primary_key=True) --> int 自增的 主键
2. models.CharField(max_length=32, null=True) --> varchar(32)
3. models.IntegerField() # int 总结一下：
models.py MySQL
类 对应 数据表
类的属性 对应 数据库里面的字段（列）
对象 对应 一行数据（一条数据） ORM到底是什么？ 对象关系映射 数据行的操作：
增：两种
1. models.User.objects.create(**{}) 直接创建并且提交到数据库
2. user = models.User(**{}) user.save() 删:
找到对象删除
models.User.objects.filter().delete() 改：
更新 两种
1. models.User.objects.filter().update(username="一枝花")
2. user = models.User.objects.get(id=1) user.username="梁志华" user.save() 查：
models.User.objects.all()
models.User.objects.get(条件) 不满足条件就报错|返回的是一个对象
models.User.objects.filter(条件) 不满足条件不报错，但是返回的结果是一个对象的列表
models.User.objects.filter().first()
models.User.objects.filter().last() models.User.objects.exclude(条件)
orm结构笔记
Django之ORM的含义
O-->object
R--->relational（链接）
M--->mapping（映射）
orm介绍
orm概念
对象映射关系模式是一种为了解决面相对象与关系数据库存在的互不匹配的现象的技术
,简单来说orm是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动化持久关旭数据库中.orm在业务逻辑层和数据层之间充当了桥梁的作用
我们的数据库操作相对比较复杂,我们在django框架的基础上,使用的这个orm就可以在不使用数据库的基础上,对数据库里面的信息进行操作,执行起来更加的简单,便捷,
orm由来
我们的所有软件开发过程中都是会涉及到对象和关系数据库在用户层面和业务逻辑层面我们是面相对象的,当对象的信息发生变化的时候我们需要把对象的信息保存到关系数据库中
按照之前的方法来进行开发就会出现程序员自己的业务逻辑代码中夹杂着很多的sql语句来增加,读取,修改和删除相关数据,而这些代码通常都是重复的,
orm的优势
它主要问题是解决关系的映射,它通常把一个类和一个表一一对应
类的每个实例对应表中的一条数据,类的每个属性对应表中的每个字段
orm提供了对数据库的映射,不用直接编写sql语句,只需要像操作对象一样从数据库里操作数据,让发开发人员专注于开发自己的业务逻辑处理,提高了开发效率
orm的劣势
orm的缺点是会在一定程度上牺牲程序员的执行效率,而且用得多了以后我们就会忘记sql语句如何写了,关系数据库的相关技能会退化...所有的自动化机制都是这样的,把人力从繁杂的劳动中解放出来然后相关的技能呢就会退化,就会更加的依赖于机器,或者更加便捷的程序,就像我们的机器人总动员一样,剧中最后船长甚至没有自由行走的能力都是因为过度依赖于过分便捷的机器导致的.
orm总结,
orm只是一种工具,工具确实能够解决一些重复简单的劳动,这是不可否认的.
但我们不能指望某个工具一劳永逸地解决所有问题,一些特殊问题还是需要特殊处理的,
但是在整个软件开发过程中需要特殊处理的情况应该都是很少的,否则所谓的工具也就失去了它存在的意义.
model
model是django中数据的单一明确的信息来源,它包含了你所存储的数据的重要字段,和行为,通常一个模型model映射到一个数据表格
基本情况:
每个模型都是一个python类,它是django.db.model的子类
模型的每个属性都代表了一个数据库字段
综上所述,django为您提供了一个自动生成的数据库访问api,
表格的名字是自动生成的,如果你要自定义表名,需要在model的Meta类中定义db_table参数,一般会写成小写的表名,格式就是在我们定义好的类和类属性下面,如下所示:
class Pupil(models.Model):
id = models.AutoField(primary_key=True) #自增id
sname = models.CharField(max_length=30, null=True) #相当vachar
age = models.IntegerField(null=True) #int 默认为空
# cid = models.IntegerField()
class Meta:
db_table = 'pupil'
通过django 类名是前面有前缀 但是这么些名字会改变没有后缀
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表示字符长度 TextField(Field)
- 文本类型 EmailField(CharField)：
- 字符串类型，Django Admin以及ModelForm中提供验证机制 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 = "" 上传文件的保存路径
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] 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)
- 二进制类型
常用字段
class UnsignedIntegerField(models.IntegerField):
def db_type(self, connection):
return 'integer UNSIGNED' PS: 返回值为字段在数据库中的属性，Django字段默认的值为：
'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)', 自定义一个无符号整数字段
自定义字段
class FixedCharField(models.Field):
"""
自定义的char类型的字段类
"""
def __init__(self, max_length, *args, **kwargs):
self.max_length = max_length
super(FixedCharField, self).__init__(max_length=max_length, *args, **kwargs) def db_type(self, connection):
"""
限定生成数据库表的字段类型为char，长度为max_length指定的值
"""
return 'char(%s)' % self.max_length class Class(models.Model):
id = models.AutoField(primary_key=True)
title = models.CharField(max_length=25)
# 使用自定义的char类型的字段
cname = FixedCharField(max_length=25)
复制代码
自定义char字段
1.触发Model中的验证和错误提示有两种方式：
a. Django Admin中的错误信息会优先根据Admiin内部的ModelForm错误信息提示，如果都成功，才来检查Model的字段并显示指定错误信息
b. 使用ModelForm
c. 调用Model对象的 clean_fields 方法，如：
# models.py
class UserInfo(models.Model):
nid = models.AutoField(primary_key=True)
username = models.CharField(max_length=32) email = models.EmailField(error_messages={'invalid': '格式错了.'}) # views.py
def index(request):
obj = models.UserInfo(username='', email='uu')
try:
print(obj.clean_fields())
except Exception as e:
print(e)
return HttpResponse('ok') # Model的clean方法是一个钩子，可用于定制操作，如：上述的异常处理。 2.Admin中修改错误提示
# admin.py
from django.contrib import admin
from model_club import models
from django import forms class UserInfoForm(forms.ModelForm):
age = forms.IntegerField(initial=1, error_messages={'required': '请输入数值.', 'invalid': '年龄必须为数值.'}) class Meta:
model = models.UserInfo
# fields = ('username',)
fields = "__all__"
exclude = ['title']
labels = { 'name':'Writer', }
help_texts = {'name':'some useful help text.',}
error_messages={ 'name':{'max_length':"this writer name is too long"} }
widgets={'name':Textarea(attrs={'cols':80,'rows':20})} class UserInfoAdmin(admin.ModelAdmin):
form = UserInfoForm admin.site.register(models.UserInfo, UserInfoAdmin)
字段注意
null 数据库中字段是否可以为空
db_column 数据库中字段的列名
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'), ]
字段的参数
# 增
models.Tb1.objects.create(c1='xx', c2='oo') # 增加一条数据，可以接受字典类型数据 **kwargs
obj = models.Tb1(c1='xx', c2='oo')
obj.save() # 查
models.Tb1.objects.get(id=123) # 获取单条数据，不存在则报错（不建议）
models.Tb1.objects.all() # 获取全部
models.Tb1.objects.filter(name='seven') # 获取指定条件的数据
models.Tb1.objects.exclude(name='seven') # 去除指定条件的数据 # 删
# models.Tb1.objects.filter(name='seven').delete() # 删除指定条件的数据 # 改
models.Tb1.objects.filter(name='seven').update(gender='') # 将指定条件的数据更新，均支持 **kwargs
obj = models.Tb1.objects.get(id=1)
obj.c1 = ''
obj.save() # 修改单条数据
orm 的操作
# 获取个数
#
# models.Tb1.objects.filter(name='seven').count() # 大于，小于
#
# models.Tb1.objects.filter(id__gt=1) # 获取id大于1的值
# models.Tb1.objects.filter(id__gte=1) # 获取id大于等于1的值
# models.Tb1.objects.filter(id__lt=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lte=10) # 获取id小于10的值
# models.Tb1.objects.filter(id__lt=10, id__gt=1) # 获取id大于1 且 小于10的值 # in
#
# models.Tb1.objects.filter(id__in=[11, 22, 33]) # 获取id等于11、22、33的数据
# models.Tb1.objects.exclude(id__in=[11, 22, 33]) # not in # isnull
# Entry.objects.filter(pub_date__isnull=True) # contains
#
# models.Tb1.objects.filter(name__contains="ven")
# models.Tb1.objects.filter(name__icontains="ven") # icontains大小写不敏感
# models.Tb1.objects.exclude(name__icontains="ven") # range
#
# models.Tb1.objects.filter(id__range=[1, 2]) # 范围bettwen and # 其他类似
#
# startswith，istartswith, endswith, iendswith, # order by
#
# models.Tb1.objects.filter(name='seven').order_by('id') # asc
# models.Tb1.objects.filter(name='seven').order_by('-id') # desc # group by
#
# from django.db.models import Count, Min, Max, Sum
# models.Tb1.objects.filter(c1=1).values('id').annotate(c=Count('num'))
# SELECT "app01_tb1"."id", COUNT("app01_tb1"."num") AS "c" FROM "app01_tb1" WHERE "app01_tb1"."c1" = 1 GROUP BY "app01_tb1"."id" # limit 、offset
#
# models.Tb1.objects.all()[10:20] # regex正则匹配，iregex 不区分大小写
#
# Entry.objects.get(title__regex=r'^(An?|The) +')
# Entry.objects.get(title__iregex=r'^(an?|the) +') # date
#
# Entry.objects.filter(pub_date__date=datetime.date(2005, 1, 1))
# Entry.objects.filter(pub_date__date__gt=datetime.date(2005, 1, 1)) # year
#
# Entry.objects.filter(pub_date__year=2005)
# Entry.objects.filter(pub_date__year__gte=2005) # month
#
# Entry.objects.filter(pub_date__month=12)
# Entry.objects.filter(pub_date__month__gte=6) # day
#
# Entry.objects.filter(pub_date__day=3)
# Entry.objects.filter(pub_date__day__gte=3) # week_day
#
# Entry.objects.filter(pub_date__week_day=2)
# Entry.objects.filter(pub_date__week_day__gte=2) # hour
#
# Event.objects.filter(timestamp__hour=23)
# Event.objects.filter(time__hour=5)
# Event.objects.filter(timestamp__hour__gte=12) # minute
#
# Event.objects.filter(timestamp__minute=29)
# Event.objects.filter(time__minute=46)
# Event.objects.filter(timestamp__minute__gte=29) # second
#
# Event.objects.filter(timestamp__second=31)
# Event.objects.filter(time__second=2)
# Event.objects.filter(timestamp__second__gte=31)
orm 进阶
orm 的增删改查 班级 学生老师表
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>学生表</title>
</head>
<body>
<div><h>学生表</h></div> <table border="" style="color: #2aabd2">
<thead>
<tr>
<th>序号</th>
<th>学生ID</th>
<th>学生名字</th>
<th>学生信息</th>
<th>所在班级</th> </tr>
</thead>
<tbody>
{% for student in st_list %}
<tr>
<td>{{ forloop.counter }}</td>
<td>{{ student.id }}</td>
<td>{{ student.sname }}</td>
<td>{{ student.detail_id}}</td>
<td>{{ student.cid_id}}</td>
<td>
{# 通过get 方法取值的#}
{# <a href="/app0001/edit_student_list/?student_id={{ student.id }}" style="color:blue ; text-decoration: none">编辑</a>#}
{# 通过分组的方法取值的#}
<a href="{% url 'app0001urls:editstudentlist' student.id %}" style="color:blue ; text-decoration: none">编辑</a>
<a href="{% url 'app0001urls:deletestudentlist' student.id %}" style="color:blue ; text-decoration: none">删除</a>
</td>
</tr>
{% endfor %}
<tr>
<a href="/app0001/add_student_list/" style="color:red ; text-decoration: none">添加</a>
</tr>
</tbody> </table> </body>
</html>
student 展示表单
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>老师表</title>
</head>
<body> <table border="">
<thead>
<tr>
<th>序号</th>
<th>老师ID</th>
<th>老师姓名</th>
<th>授课班级</th>
</tr>
</thead>
<tbody>
{#teacher_list 取到所有的老师#}
{% for teacher in teacher_list %}
<tr>
<td>{{ forloop.counter }}</td>
<td>{{ teacher.id }}</td>
<td>{{ teacher.tname }}</td>
{# 授课班级的展示 老师的#}
<td>
{# 注意注意 ？？？？？这里cid #}
{# teacher.cid.all 在html不用加上括号是什么 意思就是每个 #}
{% for class in teacher.cid.all %}
{{ class.cname }}
{% endfor %}
</td> <td>
<a href="{% url 'app0001urls:deleteteacherlist' teacher.id %}">删除</a>
<a href="{% url 'app0001urls:editteacherlist' teacher.id %}">编辑</a>
</td> </tr>
{% endfor %} {# 这里注意网址 因为django 项目已经开启子项目的命名#}
<a href="{% url 'app0001urls:addteacherlist'%}">添加</a>
{# <a href="{% url 'app0001urls:addteacherlist'%}">添加</a>#}
{# <tr><a href="/app0001/add_class_list/">添加</a></tr>#}
{# <tr><a href="{% url 'app0001urls:addclasslist' %}">添加</a></tr>#} </tbody> </table> </body>
</html>
teacher 展示表单
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>老师表</title>
</head>
<body> <form action="{% url 'app0001urls:addteacherlist' %}" method="post" >
{# 这个不需要去settings 注释了#}
{% csrf_token %}
{# <input type="text" name="class_id" style="display: none">#}
老师姓名<input type="text" name="teacher_name"> {# multiple 说明是多选#} <label for="t_id"></label>
{# name 对应的value 是提交的值此时的id是多个 因为是个多选 #}
<select name="class_id" id="t_id" multiple>授课班级
{% for class in class_list %}
<option value="{{ class.id }}">{{ class.cname }}</option>
{% endfor %}
</select>
<input type="submit" value="提交">
<input type="submit" value="取消">
</form> </body>
</html>
teacher的增加
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>班级表</title>
</head>
<body> {#这里的form 表单里因为url 那里已经分组 必须是两个参数组成的url action 必须是两部分e_name1.id 就是那个\d+#}
<form action="{% url 'app0001urls:editclasslist' e_name1.id %}" method="post" >
{% csrf_token %}
{# id这里必须要有id的值为什么 因为POST 通过id的name 取值 他的值就是现在的value#}
<input type="text" name="class_id" value="{{ e_name1.id }}" style="display: none">
班级名称<input type="text" name="class_name" value='{{ e_name1.cname }}'>
{# 时间的类型注意#}
开班时间<input type="date" name="first_day" value='{{ e_name1.first_day|date:'Y-m-d'}}'>
<input type="submit" value="提交">
<a href="/app0001/class_list/">取消</a>
</form> </body>
</html>
class 的编辑
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>编辑学生表</title>
</head>
<body>
{#别名返乡解析分组 通过分组 url 参数两个 这里也要了两个 不传也行 但是考虑网址变化#}
{#e_name1.id 是编辑 通过分组拿到的arg 的值#}
<form action="{% url 'app0001urls:editstudentlist' e_svalue1.id %}" method= "post">
{% csrf_token %}
<div>
<input type="text" name="s_id" value="{{ e_svalue1.id }}" style="display: none">
学生姓名<input type="text" name="s_name" value="{{ e_svalue1.sname }}">
</div>
<div>所在班级
<label for="class_id"></label>
<select name="class_name" id="class_id">
{% for class in class_list %}
{# 编辑的默认值 判断操作 开始{% ifXX %} {% else %}结束{% endif %}#}
{% if e_svalue1.id == class.id %}
<option selected value="{{ class.id }}">{{ class.cname }}</option>
{% else %}
<option value="{{ class.id }}">{{ class.cname }}</option>
{% endif %}
{% endfor %}
</select> </div> <div>
<input type="submit" value="取消">
<input type="submit" value="提交">
</div> </form> </body>
</html>
student 的编辑
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>编辑老师表</title>
</head>
<body>
{#别名返乡解析分组 通过分组 url 参数两个 这里也要了两个 不传也行 但是考虑网址变化#}
{#e_name1.id 是编辑 通过分组拿到的arg 的值#} <form action="{% url 'app0001urls:editteacherlist' teacher_id.id %}" method="post">
{% csrf_token %}
老师姓名<input type="text" name="teacher_name" value="{{ teacher_id.tname }}">
<label for="t_id"></label>
授课班级<select name="class_id" id="t_id" multiple>
{% for class in class_list %}
{# 注意此处 如果这个班级在点击编辑老师的cid表中取得的所有对象中 .all 在html 不要加括号#}
{% if class in teacher_id.cid.all %}
<option selected value="{{ class.id }}">{{ class.cname }}</option>
{% else %}
<option value="{{ class.id }}">{{ class.cname }}</option>
{% endif %}
{% endfor %}
</select>
<div>
<input type="submit" value="取消">
<input type="submit" value="提交">
</div>
</form> {# <form action="{% url 'app0001urls:editteacherlist' %}" method= "post">#}
{##}
{# <div>#}
{# <input type="text" name="s_id" value="{{ e_svalue1.id }}" style="display: none">#}
{# 学生姓名<input type="text" name="s_name" value="{{ e_svalue1.sname }}">#}
{# </div>#}
{# <div>所在班级#}
{# <label for="class_id"></label>#}
{# <select name="class_name" id="class_id">#}
{# {% for class in class_list %}#}
{# 编辑的默认值 判断操作 开始{% ifXX %} {% else %}结束{% endif %}#}
{# {% if e_svalue1.id == class.id %}#}
{# <option selected value="{{ class.id }}">{{ class.cname }}</option>#}
{# {% else %}#}
{# <option value="{{ class.id }}">{{ class.cname }}</option>#}
{# {% endif %}#}
{# {% endfor %}#}
{# </select>#}
{##}
{# </div>#}
{##}
{# <div>#}
{# <input type="submit" value="取消">#}
{# <input type="submit" value="提交">#}
{# </div>#}
{##}
{#</form>#} </body>
</html>
teacher 的编辑
from django.shortcuts import render,redirect,HttpResponse
from app0001 import models
from django.urls import reverse
# Create your views here.
# 建表 添加数据库到页面
def class_list(request):
class_list = models.Ban_list.objects.all()
# add_class_list = models.Ban_list.objects.create(cname='Python 1期',)
# add_class_list = models.Ban_list.objects.create(cname='Python 2期',)
# add_class_list = models.Ban_list.objects.create(cname='Python 3期',)
# add_class_list = models.Ban_list.objects.create(cname='Python 4期',)
# add_class_list = models.Ban_list.objects.create(cname='Python 5期',)
# add_class_list = models.Ban_list.objects.create(cname='Linux 1期',)
# add_class_list = models.Ban_list.objects.create(cname='Linux 2期',)
# add_class_list = models.Ban_list.objects.create(cname='Linux 3期',)
# add_class_list = models.Ban_list.objects.create(cname='Linux 4期',)
# 增加
# class1= models.Ban_list.objects.create(cname='Java 1期')
# 删除
# models.Ban_list.objects.filter(id=11).delete()
# 改i
# models.Ban_list.objects.filter(id=10).update(cname='大数据1期')
# 查找
# models.Ban_list.objects.all
# c1=models.Ban_list.objects.get(id=5)
# c1 = models.Ban_list.objects.filter(id=5)
# c1 = models.Ban_list.objects.exclude(cname='Python 2期') # print(c1[5].cname)
return render(request, 'class_list.html', {'class_list':class_list}) # ORM 增加数据
def add_class_list(request):
if request.method == 'POST':
c_name = request.POST.get("class_name")
first_day = request.POST.get("first_day1")
models.Ban_list.objects.create(cname=c_name,first_day=first_day) return redirect(reverse('app0001urls:classlist')) #通过别名返回list
# return redirect('/app0001/class_list/ ') #通过真实网址返回list
return render(request, "add_class_list.html")
#
# # ORM 删除数据
def delete_class_list(request):
d_id = request.GET.get('class_id')
models.Ban_list.objects.filter(id=d_id).delete()
# 如果没有页面只能去跳转
# return redirect('/app0001/class_list/')
return redirect(reverse('app0001urls:classlist'))
# # 更改数据
def edit_class_list(request,arg):
# 这里是通过分组取值的方法得到arg,点击编辑的时候生成url 和id的值 id的值就是arg
if request.method == 'POST':
e_id = request.POST.get("class_id")
e_name1 = request.POST.get('class_name')
first1_day = request.POST.get('first_day')
models.Ban_list.objects.filter(id=e_id).update(cname=e_name1,first_day=first1_day)
return redirect(reverse('app0001urls:classlist'))
# 通过编辑的链接取值arg e_name = models.Ban_list.objects.get(id=arg)
return render(request,'edit_class_list.html',{'e_name1':e_name}) # e_id = request.GET.get('class_id') #这里是通过编辑的id 通过的是get 取值 # if request.method == 'POST':
# # e_id = request.POST.get('class_id') 这里不能取值
# # 只有在form 表单里面才能进行post 取值 别的地方就不能取值
# e_name = request.POST.get("class_name")
# models.Ban_list.objects.filter(id=e_id).update(cname=e_name)
# # return redirect('/app0001/class_list/')
# return redirect(reverse('app0001urls:classlist'))
#
# # e_name= models.Ban_list.objects.get(id=e_id) #get 取一条是一个对象
# e_name1 = models.Ban_list.objects.filter(id=e_id) #filter 取一条是一个表 必须加索引
# e_name1 = e_name1[0] #此变量对应后边编辑的默认的值
# return render(request, 'edit_class_list.html', {'e_name1':e_name1}) #
# # 建表 添加数据库的页面
def student_list(request):
st_list = models.Student_list.objects.all()
return render(request, 'student_list.html', {'st_list': st_list}) def add_student_list(request):
if request.method == 'POST':
sname1 = request.POST.get('s_name')
cid1 = request.POST.get('class_id')
# 方法一 通过 cid的值操作 注意这cid_id 这个是Student_list 通过外键形成的，cid 是个对象 cid_id 是个数字
# models.Student_list.objects.create(sname=sname1,cid_id=cid1) # 方法二 通过orm 对象 对应的 学生表的cid对象 而不是cid_idd的值数字
object_c = models.Ban_list.objects.get(id=cid1)
models.Student_list.objects.create(sname=sname1, cid=object_c)
return redirect(reverse('app0001urls:studentlist')) class_list = models.Ban_list.objects.all()
return render(request, 'add_student_list.html',{'class_list':class_list}) def delete_student_list(request,sid):
# 通过url分组取值的方法
models.Student_list.objects.filter(id=sid).delete() # 通过get取值的方法
# d_id = request.GET.get('student_id')
# models.Student_list.objects.filter(id=d_id).delete()
return redirect(reverse('app0001urls:studentlist')) # def edit_student_list(request):
# e_id = request.GET.get('student_id')
# if request.method == 'POST':
# e_sname = request.POST.get('s_name')
# e_cid = request.POST.get('c_id')
# models.Student_list.objects.filter(id=e_id).update(sname=e_sname,cid=e_cid)
# return redirect(reverse('app0001urls:studentlist')) # e_id = request.GET.get('student_id')
# e_svalue2 = models.Student_list.objects.filter(id=e_id)
# e_svalue= e_svalue2[0]
# return render(request, 'edit_student_list.html', {'e_svalue1':e_svalue}) # def edit_student_list(request,arg):
# # e1_svalue = models.Student_list.objects.filter(id=arg)
# if request.method == 'POST':
# # 只有在form 表单里面才能进行post 取值 别的地方就不能取值
# e_name = request.POST.get("class_name")
# models.Ban_list.objects.filter(id=e_id).update(cname=e_name)
# # return redirect('/app0001/class_list/')
# return redirect(reverse('app0001urls:classlist'))
#
# e1_svalue= models.Student_list.objects.filter(id=arg)
# e1_svalue= e1_svalue[0]
# return render(request,'edit_student_list.html',{'e_svalue1':e1_svalue})
def edit_student_list(request,sid):
if request.method == 'POST':
sname1 = request.POST.get('s_name')
class1 = request.POST.get('class_name')
# 方法一 通过分组get 得到一个对象不支持链式操作
# student_obj = models.Student_list.objects.get(id=sid)
# student_obj.sname = sname1
# 注意student_obj 是个对象 学生表链表后 cid 是对象 cid_id 是班级的id
# student_obj.cid_id = class1
# student_obj.save()
# 方法二直接filter 取值 后边直接链式操作
models.Student_list.objects.filter(id=sid).update(sname=sname1, cid_id=class1) return redirect(reverse('app0001urls:studentlist'))
# 先通过分组拿到带有值得form 表单取得对象能链式操作
e_svalue1 = models.Student_list.objects.get(id=sid)
# 取得班级的列表
class_list = models.Ban_list.objects.all()
return render(request,'edit_student_list.html', {'class_list': class_list,'e_svalue1': e_svalue1}) def teacher_list(request): teacher_list = models.Teacher.objects.all()
# cid代表进入一张表 并没有拿取对象
return render(request,'teacher_list.html',{'class_list':class_list,'teacher_list':teacher_list}) def add_teacher_list(request):
if request.method == 'POST':
teacher_name =request.POST.get('teacher_name')
# 通过取得select name 班级的多个id值 的name??????
class_ids =request.POST.getlist('class_id')
# 第一种数据库直接添加 去数据库插入一条信息 老师这个对象 数据库
print(class_ids)
# teacher_obj = models.Teacher.objects.create(tname=teacher_name)
# # 这个老师对象的授课班级表添加id 因为是列表需要打算添加
# teacher_obj.cid.add(*class_ids)
# print(teacher_obj.cid) # 第二中表里添加对象 是之通过条件id增加 注意单个id是可以直接等于 多个的话下划线id__in
teacher_obj = models.Teacher.objects.create(tname=teacher_name)
class_objs = models.Ban_list.objects.filter(id__in=class_ids)
teacher_obj.cid.add(*class_objs) return redirect(reverse('app0001urls:teacherlist'))
class_list = models.Ban_list.objects.all()
return render(request,'add_teacher_list.html',{'class_list':class_list}) def delete_teacher_list(request,tid):
models.Teacher.objects.filter(id=tid).delete()
return redirect(reverse('app0001urls:teacherlist')) def edit_teacher_list(request,tid):
teacher_obj = models.Teacher.objects.get(id=tid)
if request.method == 'POST':
t_name=request.POST.get('teacher_name')
class_ids=request.POST.getlist('class_id')
# 注意这个要保存
teacher_obj.tname=t_name
teacher_obj.save()
teacher_obj.cid.set(class_ids)
return redirect(reverse('app0001urls:teacherlist'))
class_list = models.Ban_list.objects.all()
teacher_id = models.Teacher.objects.get(id=tid)
return render(request,'edit_teacher_list.html',{'class_list':class_list,'teacher_id':teacher_id})
orm view视图 练习增删改查
关于orm 的基础3 day67的更多相关文章
- 【python】-- Django ORM（基础）
Django ORM(基础) Django 框架十分强大,自带数据库操作功能.Django 跟 SQLAchemy 一样,也是通过ORM(Object Relational Mapping,关系对象映 ...
- ORM之基础操作进阶
一.外键自关联(一对多) 1.建表 # 评论表 class Comment(models.Model): id = models.AutoField(primary_key=True) content ...
- day 67 django orm的基础
django项目 安装: 创建项目 配置(setting,static,csrf) 创建app,python manage.py startapp app1 三部分 urls.py路由配置 1,普通正 ...
- C#基础系列：实现自己的ORM（反射以及Attribute在ORM中的应用）
反射以及Attribute在ORM中的应用 一. 反射什么是反射?简单点吧,反射就是在运行时动态获取对象信息的方法,比如运行时知道对象有哪些属性,方法,委托等等等等.反射有什么用呢?反射不但让你在运行 ...
- day 67 django 之ORM 基础安装
一 ORM的基础部分 1 ORM的概念 对象关系映射(Object Relational Mapping(映射),简称ORM)模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术. 2 ...
- Django之Models与ORM操作
一.models例子 from django.db import models class User(models.Model): """ 用户表 "" ...
- 【Mysql的那些事】数据库之ORM操作
1:ORM的基础操作(必会) <1> all(): 查询所有结果 <2> filter(**kwargs): 它包含了与所给筛选条件相匹配的对象 <3> get(* ...
- 目录（Python基础）
Python之介绍.基本语法.流程控制 Python之列表.字典.集合 Python之函数.递归.内置函数 Python之迭代器.装饰器.软件开发规范 Python之常用模块学习(一) Python之 ...
- ADO.NET Entity Framework 在哪些场景下使用？
在知乎回答了下,顺手转回来. Enity Framework已经是.NET下最主要的ORM了.而ORM从一个Mapping的概念开始,到现在已经得到了一定的升华,特别是EF等对ORM框架面向对象能力的 ...
随机推荐
- bzoj3676: [Apio2014]回文串 pam
题意:字符串s.我们定义s的一个子串t的"出 现值"为t在s中的出现次数乘以t的长度.请你求出s的所有回文子串中的最 大出现值. 题解:pam板子题 //cnt数组表示该节点代表的 ...
- shiro中SSL
对于SSL的支持,Shiro只是判断当前url是否需要SSL登录,如果需要自动重定向到https进行访问. 首先生成数字证书,生成证书到D:\localhost.keystore 使用JDK的keyt ...
- 【微信公众号开发】【10】JSJDK相关
前言: 1,优点:官方提供的,会调用后还算使用方便,不用费劲了解各个原生组件 缺点:使用上有限制(如:上传文件有大小限制),很容易踩坑,部分安卓手机及电脑端不支持pjax 总结:上手容易,坑很多 2, ...
- mac终端下连接阿里云服务器
通过ssh连接 ssh 用户名@地址 ssh root@xx.xxx.xxx.xx https://www.jianshu.com/p/f034817a7837 最后还是通过 FileZilla 连 ...
- Git冲突：commit your changes or stash them before you can merge.
用git pull来更新代码的时候,遇到了下面的问题: error: Your local changes to the following files would be overwritten by ...
- SVN 多分支管理
SVN 新建时可以选择性的建立三个文件夹 trunk 一般作为主开发的地方 branches 一般作为从trunk Copy过去的代码,形成分支 tags ...
- Git的安装和创建版本库
1.Git是分布式版本控制系统 2.安装Git 下载Git后,按照默认设置即可实现安装,安装完毕后点击git目录下的Git Bash 输入以下命令符: git config --global user ...
- [洛谷 P1972] HH的项链(SDOI2009)
P1972 [SDOI2009]HH的项链 题目描述 HH 有一串由各种漂亮的贝壳组成的项链.HH 相信不同的贝壳会带来好运,所以每次散步完后,他都会随意取出一段贝壳,思考它们所表达的含义.HH 不断 ...
- #pragma 处理警告 clang diagnostic 的使用
首先#pragma在本质上是声明,常用的功能就是注释,尤其是给Code分段注释:而且它还有另一个强大的功能是处理编译器警告,但却没有上一个功能用的那么多. clang diagnostic 是#pra ...
- html 打电话 发短信
打电话:window.location.href = 'tel:'+tel 发短信:window.location.href = 'sms:'+tel