def db_handle(request):
if request.method == 'POST':
print(request.POST)
book_name = request.POST.get('name')
publisher_id = request.POST.get('publisher_id')
print('==>', request.POST.get('author_ids'))
author_ids = request.POST.getlist('author_ids')
print(book_name, publisher_id, author_ids)
new_book = models.Book(title=book_name,
publisher_id=publisher_id,
publication_date='2017-05-22')
new_book.save()
new_book.authors.add(*author_ids)
#new_book.authors.add(1,2,3,4)
books = models.Book.objects.all()
publisher_list = models.Publisher.objects.all()
author_list = models.Author.objects.all()
return render(request, 't1.html', {
'books': books,
'publishers': publisher_list,
'authors': author_list,
})
def another_add(request):
author_obj = models.Author.objects.first()
book = models.Book(name="怎样打铁")
# book.author = author_obj
author_obj.booklist.add(book, bulk=False)
return HttpResponse("增加成功啦！！！")
def add_book(request):
book_list = models.Book.objects.all()
publisher_list = models.Publisher.objects.all()
author_list = models.Author.objects.all()
if request.method == 'POST' and request.POST:
book_name = request.POST.get('book_name')
print '书名: %s' % (book_name)
publisher = request.POST.get('publisher')
print '出版社ID: %s' % (publisher)
publish_date = request.POST.get('date')
print '出版日期: %s' % (publish_date)
author = request.POST.getlist('author')
print '作者ID: %s' % (author)
new_book = models.Book(name=book_name,
publisher_id=publisher,
publish_date=publish_date)
new_book.save()
new_book.author.add(*author)
return HttpResponse('New Book %s Add Success...' % (book_name))
return render(
request, 'add_book.html', {
'book_list': book_list,
'publisher_list': publisher_list,
'author_list': author_list
})
def boot_list(request):
if request.is_ajax():
back_dic = {'code':200,'msg':''}
delete_id = request.POST.get('delete_id')
time.sleep(1)
models.Book.objects.filter(pk=delete_id).delete()
back_dic['msg'] = "删除成功"
return JsonResponse(back_dic)
# # ORM 的循环插入数据更快捷的方法：
book_list = []
for i in range(1000):
book_list.append(models.Book(title='第%s本书'%i,price=100,publish_id=100))
models.Book.objects.bulk_create(book_list)
# 查询所有的书籍。
book_list = models.Book.objects.all()
# 自定义分页器的使用
current_page = request.GET.get('page',1)
all_count = book_list.count()
page_obj = Pagination(current_page=current_page,
all_count=all_count,
per_page_num=15,
pager_count=11)
# 参数说明：
# current_page 当前的页数
# all_count 所有的页数
# per_page_num 每页显示多少
# pager_count 分页器显示的条数
page_queryset = book_list[page_obj.start:page_obj.end]
return render(request,'book_list.html',locals())
def add_more_book(request):
author_obj = models.Author.objects.first()
book = models.Book(name="怎样打坦克")
book.author = author_obj
book.save()
return HttpResponse("Success")
def add_book(request):
book = models.Book(title="菜鸟教程",
price=300,
publish="菜鸟出版社",
pub_date="2008-8-8")
book.save()
return HttpResponse("<p>数据添加成功！</p>")
def add_book1(request):
book = models.Book(title='QI Konws',
price=99,
publish='BZH',
pub_date='2020-7-20')
book.save()
return HttpResponse("<p>Method1 数据添加成果</p>")
def book(request):
if request.method == "POST":
choose_date = request.POST.get("choose_date")
# print("choose_date:", choose_date)
# 获取房间时间段列表
time_choice = models.Book.time_choice
try:
# 向数据库修改房间预订记录
post_data = json.loads(request.POST.get("post_data"))
if not post_data["ADD"] and not post_data["DEL"]:
res = {"status": 2, "msg": ""}
return HttpResponse(json.dumps(res))
user = request.user
# print(type(post_data), post_data)
# 添加新的预订信息
book_list = []
for room_id, time_id_list in post_data["ADD"].items():
for time_id in time_id_list:
book_obj = models.Book(user=user,
room_id=room_id,
time_id=time_id,
date=choose_date)
book_list.append(book_obj)
models.Book.objects.bulk_create(book_list)
# 删除旧的预订信息
from django.db.models import Q
remove_book = Q()
for room_id, time_id_list in post_data["DEL"].items():
temp = Q()
for time_id in time_id_list:
temp.children.append(("room_id", room_id))
temp.children.append(("time_id", time_id))
temp.children.append(("user_id", request.user.pk))
temp.children.append(("date", choose_date))
remove_book.add(temp, "OR")
if remove_book:
models.Book.objects.filter(remove_book).delete()
for time in post_data["DEL"][room_id]:
models.Book.objects.filter(user=user,
room_id=room_id,
time_id=time,
date=choose_date).delete()
res = {"status": 1, "msg": ''}
except Exception as e:
res = {"status": 0, "msg": str(e)}
return HttpResponse(json.dumps(res))
def add(request):
if request.method == "POST":
print(request.POST)
title = request.POST.get("title")
pubdate = request.POST.get("pubdate")
price = request.POST.get("price")
publish = request.POST.get("publish")
# 插入数据方式1,create有返回值：插入的记录对象：
# book_obj=models.Book.objects.create(title=title,pubDate=pubdate,price=price,publish=publish)
# print(book_obj.title)
# print(book_obj.price)
# 插入数据方式2：
book_obj = models.Book(title=title, pubDate=pubdate, publish=publish)
book_obj.price = price
book_obj.save()
return redirect("/index/")
return render(request, "add2.html")
def book_form(request):
form = forms.BookForm()
if request.method == "POST":
print(request.POST)
form = forms.BookForm(request.POST)
if form.is_valid():
print("form is OK")
print(form.cleaned_data)
form_data = form.cleaned_data
print(form_data)
form_data['publisher_id'] = request.POST.get('publisher_id')
book_obj = models.Book(**form_data)
book_obj.save()
else:
print(form.errors)
publisher_list = models.Publisher.objects.all()
print(form)
return render(request, 'form.html', {
'book_form': form,
'publishers': publisher_list,
})
def ormadd(request):
#orm2添加一条记录的方法
#单表
#1、表.objects.create（）
models.Publish.objects.create(name='浙江出版社',addr="浙江.杭州")
models.Classify.objects.create(category='武侠')
models.Author.objects.create(name='金庸',sex='男',age=89,university='东吴大学')
# #2.obj=类（属性=XX） obj.save()
obj=models.Author(name='吴承恩',age=518,sex='男',university='龙溪学院')
obj.save()
# 1对多
# 1.表.objects.create()
models.Book.objects.create(title='笑傲江湖',price=200,date=1968,classify_id=6, publish_id=6)
#2、obj=类（属性=X,外键=obj）obj.save()
classify_obj=models.Classify.objects.get(category='武侠')
publish_obj=models.Publish.objects.get(name='河北出版社')
# #注意以上获取得是和 book对象 向关联的（外键）的对象
book_obj=models.Book(title='西游记',price=234,date=1556,classify=classify_obj,publish=publish_obj)
book_obj.save()
#多对多：如果两表之间存在双向1对N关系，就无法使用外键来描述其关系了；
# 只能使用多对多的方式，新增第三张表关系描述表；
book=models.Book.objects.get(title='笑傲江湖')
author1=models.Author.objects.get(name='金庸')
author2=models.Author.objects.get(name='张根')
book.author.add(author1,author2)
# 书籍和作者是多对多关系，
# 切记：如果两表之间存在多对多关系，例如书籍相关的所有作者对象集合，作者也关联的所有书籍对象集合
book=models.Book.objects.get(title='西游记')
author=models.Author.objects.get(name='吴承恩')
author2 = models.Author.objects.get(name='张根')
book.author.add(author,author2)
#add() 添加
#clear() 清空
#remove() 删除某个对象
return HttpResponse('OK')
def book(request):
if request.method == 'POST':
print(request.POST)
book_name = request.POST.get('name')
publisher_id = request.POST.get('publisher_id')
print('==>', request.POST.get('author_ids'))
author_ids = request.POST.getlist('author_ids')
print(book_name, publisher_id, author_ids)
new_book = models.Book(name=book_name,
publisher_id=publisher_id,
publish_date='2017-09-28')
new_book.save()
new_book.authors.add(*author_ids)
books = models.Book.objects.all()
publisher_list = models.Publisher.objects.all()
author_list = models.Athor.objects.all()
return render(request, 'app01/book.html', {
'books': books,
'publishers': publisher_list,
'authors': author_list,
})
def booking(reqeust):
if reqeust.method == "GET":
response = {'status':True,'msg':None,'data':None}
try:
import datetime
current_date = datetime.datetime.now().date()
choice_date = reqeust.GET.get('choice_date')
choice_date = datetime.datetime.strptime(choice_date, '%Y-%m-%d').date()
if choice_date < current_date:
raise Exception('日期必须大于等于当前')
booking_list = models.Book.objects.filter(date=choice_date)
print(models.Book.date)
booking_dict = {}
for item in booking_list:
if item.room_id not in booking_dict:
booking_dict[item.room_id] = {item.time_id: {'name': item.user.user, 'id': item.user_id}}
else:
booking_dict[item.room_id][item.time_id] = {'name': item.user.user, 'id': item.user_id}
# ############ 生成会议室信息 #################
booking_info = []
room_list = models.Room.objects.all()
for room in room_list:
td_list = [{'text':room.caption,'attrs':{}}, ]
for tm in models.Book.time_choices:
if room.id in booking_dict and tm[0] in booking_dict[room.id]:
# 已预定
user_info = booking_dict[room.id][tm[0]]
#if user_info == request.session['xxxxx']['id']:
# 登录用户1，少尉
# 登录用户2，海东
if user_info['id'] == 2:
# 自己预定
# print(room.id, room.caption, tm[0], tm[1], user_info['name'])
td_list.append({'text': '自己预定', 'attrs': {'class':'chosen','room_id':room.id,'time_id':tm[0]}})
else:
# 别人预定
# print(room.id, room.caption, tm[0], tm[1], user_info['name'], 'disabled')
td_list.append({'text': user_info['name'], 'attrs': {'room_id':room.id,'time_id':tm[0],'class':'chosen','f**k':'true'},})
else:
td_list.append({'text':'','attrs':{ 'room_id':room.id,'time_id':tm[0] }})
booking_info.append(td_list)
response['data'] = booking_info
except Exception as e:
response['status'] = False
response['msg'] = str(e)
return JsonResponse(response)
else:
response = {'status': True, 'msg': None, 'data': None}
try:
import datetime
current_date = datetime.datetime.now().date()
choice_date = reqeust.POST.get('date')
choice_date = datetime.datetime.strptime(choice_date, '%Y-%m-%d').date()
if choice_date < current_date:
raise Exception('日期必须大于等于当前')
post_data = json.loads(reqeust.POST.get('data'))
# {'DEL': {'4': ['5','6'],'7':[1,2]}, 'ADD': {'1': ['2', '3'], '2': ['3'], '4': ['5']}}
for room_id,time_list in post_data['DEL'].items():
if room_id not in post_data['ADD']:
continue
for time_id in list(time_list):
if time_id in post_data['ADD'][room_id]:
post_data['ADD'][room_id].remove(time_id)
post_data['DEL'][room_id].remove(time_id)
# 增加预定
book_obj_list = []
for room_id,time_list in post_data['ADD'].items():
for time_id in time_list:
# models.Book.objects.create(room_id=room_id,time_id=time_id,user_id=2,date=choice_date)
obj = models.Book(room_id=room_id, time_id=time_id, user_id=2, date=choice_date)
book_obj_list.append(obj)
models.Book.objects.bulk_create(book_obj_list)
# 删除会议室预定信息
from django.db.models import Q
remove_booking = Q()
for room_id, time_id_list in post_data['DEL'].items():
for time_id in time_id_list:
temp = Q()
temp.connector = 'AND'
temp.children.append(('user_id',2,))
temp.children.append(('date', choice_date))
temp.children.append(('room_id', room_id,))
temp.children.append(('time_id', time_id,))
remove_booking.add(temp, 'OR')
if remove_booking:
models.Book.objects.filter(remove_booking).delete()
except Exception as e:
response['status'] = False
response['msg'] = str(e)
return JsonResponse(response)
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "自定增删改查的组件.settings")
import django
django.setup()
from app01 import models
# 批量添加数据
book_list = []
for i in range(1,101):
new_book_obj = models.Book(title="book_{}".format(i))
book_list.append(new_book_obj)
models.Book.objects.bulk_create(book_list)
def initBook(request):
if request.method == 'GET':
user_id = request.session['user'].get('id')
rooms = models.Room.objects.all()
time_choices = models.Book.time_choice
date = request.GET.get('date')
date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
nowdate = datetime.datetime.now().date()
if date >= nowdate:
books = models.Book.objects.filter(date=date)
print(books)
book_dic = {}
for book in books:
if book.room_id in book_dic:
book_dic[book.room_id][book.time] = {
'username': book.user.name,
'userid': book.user.id
}
else:
book_dic[book.room_id] = {
book.time: {
'username': book.user.name,
'userid': book.user.id
}
}
data = []
for room in rooms:
tr = []
tr.append({'text': room.name, 'attrs': {}})
for tm in time_choices:
if room.id in book_dic and tm[0] in book_dic[room.id]:
if user_id == book_dic[room.id][tm[0]]['userid']:
td = {
'text': book_dic[room.id][tm[0]]['username'],
'attrs': {
'roomid': room.id,
'tm': tm[0],
'class': "chosen"
}
}
else:
td = {
'text': book_dic[room.id][tm[0]]['username'],
'attrs': {
'roomid': room.id,
'tm': tm[0],
'class': "chosen",
'fk': 'true'
}
}
else:
td = {
'text': '',
'attrs': {
'roomid': room.id,
'tm': tm[0]
}
}
tr.append(td)
data.append(tr)
reponse = {"data": data}
print(data)
return JsonResponse(reponse)
else:
raise Exception("只能预定今天或者以后的会议室")
elif request.method == "POST":
response = {'status': True, 'msg': None, 'data': None}
try:
print(123)
date = request.POST.get('date')
date = datetime.datetime.strptime(date, '%Y-%m-%d').date()
nowdate = datetime.datetime.now().date()
data = request.POST.get('data')
data = json.loads(data)
print(date)
print(data)
if date >= nowdate:
#判断del和add中有没有重复
for room_id, tm_list in data.get("del").items():
if room_id not in data.get('add'):
continue
for tm in list(tm_list):
if tm in data['add'][room_id]:
data['del'][room_id].remove(tm)
data['add'][room_id].remove(tm)
#增加预定
add_list = []
user_id = request.session['user'].get('id')
for room_id, tm_list in data['add'].items():
for tm in tm_list:
book = models.Book(room_id=room_id,
user_id=user_id,
date=date,
time=tm)
add_list.append(book)
models.Book.objects.bulk_create(add_list)
#取消预定
from django.db.models import Q
remove_books = Q()
for room_id, tm_list in data['del'].items():
print(room_id, '-------')
for tm in tm_list:
print(tm, '******')
temp = Q()
temp.connector = 'AND'
temp.children.append(('user_id', user_id))
temp.children.append(('date', date))
temp.children.append((
'room_id',
room_id,
))
temp.children.append((
'time',
tm,
))
remove_books.add(temp, 'OR')
if remove_books:
print(remove_books)
print(123)
models.Book.objects.filter(remove_books).delete()
else:
raise Exception("只能预定今天或者以后的会议室")
except Exception as e:
response['status'] = False
response['msg'] = str(e)
return JsonResponse(response)
def add_book(request):
# 记录的增删改查
# 1添加
# 添加数据记录 方式1
new_book = models.Book(
title='金瓶梅',
price=9.91,
# pub_date=datetime.datetime.now()
# 添加时间日期类型数据时可以是时间日期类型的数据,
# 也可以是字符串数据
pub_date='2022-02-02',
publish='32期出版社'
# 有默认值的或者可以为空的或者主键字段,都可以不用传值
)
# new_book.save()
# 添加方式2 create方法,create方法的返回值为 新添加的数据的模型类对象
# new_book = models.Book.objects.create(
# title='金瓶梅4',
# price=19.9,
# pub_date='2020-04-02',
# publish='32期出版社'
# )
# print(new_book.title) #金瓶梅4
# print(new_book.price) #19.9
# 批量添加
# obj_list = []
# for i in range(2):
# book_obj = models.Book(
# title=f'少年闰土{i}',
# # 和js的$(变量名)取值类似
# price=10 + i,
# pub_date=f'2022-04-1{i}',
# publish='32期出版社'
# )
# obj_list.append(book_obj)
#
# print(obj_list)
# # [<Book: Book object>, <Book: Book object>,
# # [<Book: 少年闰土0>, <Book: 少年闰土1>] models中加了 __str__魔术方法
# models.Book.objects.bulk_create((obj_list)) #bulk_create 批量添加
# 2 查询
# 01 查询所有
# book_objs = models.Book.objects.all() # #queryset 类似于列表
# print(book_objs)
# <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>,
#02 指定条件查询 方法1
# 结果为queryset类型数据
# book_objs = models.Book.objects.filter(id=4)
# print(book_objs)
# <QuerySet [<Book: 金瓶梅4>]>
# book_objs = models.Book.objects.filter()
# # filter没有加条件,和all一样的效果
# print(book_objs)
# <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>,
# book_objs = models.Book.objects.filter(id=100)
# print(book_objs)
# <QuerySet []>
#02 指定条件查询 方法2
# book_objs = models.Book.objects.get(id=4)
# ## 条件查找 结果为: 模型类对象
# print(book_objs)
# #金瓶梅4
# book_objs = models.Book.objects.get() #查所有
# # 但是get方法的查询结果有要求,有且只能有一条
# print(book_objs)
# book_objs = models.Book.objects.get(id=100) # 查询不到结果会报错 Book matching query does not exist.
# # 查询结果多于一条也会报错
# print(book_objs)
# get() returned more than one Book -- it returned 16!
# 3 删除 方法1
# models.Book.objects.filter(id=3).delete()
#queryset类型数据可以调用delete方法删除查询结果数据
# 方法2
# models.Book.objects.get(id=4).delete()
# 4 修改
# 修改方式1 通过queryset类型数据修改
# models.Book.objects.filter(id=5).update(
# price=20,
# title='读书'
# )
# models.Book.objects.get(id=5).update(
# price=30, #报错:模型类对象不能调用update方法
# )
# 'Book' object has no attribute 'update'
# 修改方式2 通过模型类对象来修改
# ret = models.Book.objects.get(id=5)
# ret.price = 30
# ret.title = '健身'
# ret.save()
# DatetimeField、DateField、TimeField这个三个时间字段，都可以设置如下属性
# (7)auto_now_add
# 配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。
#
# (8)auto_now
# 配置上auto_now=True，每次更新数据记录的时候会更新该字段，
# 标识这条记录最后一次的修改时间。
# 测试auto_now和auto_now_add两个参数
# 新添加的数据的模型类对象
# models.userinfo.objects.create(
# name='xx3',
# )
# models.userinfo.objects.filter(id=1).update(
# # ( #update不能触发自动更新时间的auto_now参数的作用,
# # # 如果用update方法来更新记录,并保存更新记录的时间,
# # 需要我们手动给该字段传入当前时间
# name='投资',
# b1 = datetime.datetime.now()
# )
# 这种save方式能够触发auto_now参数自动更新修改时间的动作
# ret = models.userinfo.objects.get(id=1)
# ret.name = '读书'
# ret.save()
# 基于双下划线的模糊查询
# 查询书名以少年开头的哪些书
# obj_list = models.Book.objects.filter(title__startswith='少年')
# #以什么开头
# print(obj_list)
# #<QuerySet [<Book: 少年闰土1>, <Book: 少年闰土2>,
# obj_list = models.Book.objects.filter(title__endswith='梅')
# #以什么结尾
# print(obj_list)
# # <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>]>
# obj_list = models.Book.objects.filter(title__startswith='p')
# print(obj_list)
# <QuerySet [<Book: python少年闰土1>]>
# obj_list = models.Book.objects.filter(title__istartswith='p')
# #不区分大小写
# print(obj_list)
# # <QuerySet [<Book: python少年闰土1>, <Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(title__contains='th')
# #包含
# print(obj_list)
# # <QuerySet [<Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(title__icontains='th')
# #包含 不区分大小写
# print(obj_list)
# # <QuerySet [<Book: pytHon少年闰土1>, <Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(price__gt=18) #大于
# print(obj_list)
# # <QuerySet [<Book: 健身>, <Book: 少年闰土9>]>
# obj_list = models.Book.objects.filter(price__gte=19) #大于等于
# print(obj_list)
# <QuerySet [<Book: 健身>, <Book: 少年闰土9>]>
# obj_list = models.Book.objects.filter(price__lt=10) #小于
# print(obj_list)
# #<QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>]>
# obj_list = models.Book.objects.filter(price__lte=10) #小于等于
# print(obj_list)
# QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>, <Book: 少年闰土0>]>
# obj_list = models.Book.objects.filter(price__in=[15,18,30])
# #价格等于15或者等于18或者等于30的书籍
# print(obj_list)
# #<QuerySet [<Book: 健身>, <Book: 少年闰土5>, <Book: 少年闰土8>]>
# obj_list = models.Book.objects.filter(price__range=[15,17])
# #价格大于等于15并且小于等于17, between and
# print(obj_list)
#<QuerySet [<Book: 少年闰土5>, <Book: 少年闰土6>, <Book: 少年闰土7>]>
# obj_list = models.Book.objects.filter(id=10,price=15)
# #逗号连接的查询条件就是and的关系
# print(obj_list)
# <QuerySet [<Book: 少年闰土5>]>
# obj_list = models.Book.objects.filter(pub_date__year='2020')
# #2020年的所有书籍
# print(obj_list)
# # <QuerySet [<Book: 少年闰土1>]>
# obj_list = models.Book.objects.filter\
# (pub_date__year='2020',pub_date__month='04')
# #2020年4月份的所有书籍
# print(obj_list)
# # <QuerySet [<Book: 少年闰土1>]>
# obj_list = models.Book.objects.filter(pub_date__year='2020',
# pub_date__month='04',
# pub_date__day='11')
# # 2020年4月11号的所有书籍 方法1
# print(obj_list)
# # # <QuerySet [<Book: 少年闰土1>]>
obj_list = models.Book.objects.filter(pub_date='2020-04-11')
# # 2020年4月11号的所有书籍 方法2 推荐
print(obj_list)
# # # <QuerySet [<Book: 少年闰土1>]>
return HttpResponse('ok')
def addata(request):
"""
批量添加数据
:param request:
:return:
"""
# 批量插入Publisher表
models.Publisher.objects.bulk_create([
models.Publisher(name="人民出版社",
address="福州",
city="福州",
state_province="福建",
country="中国",
website="http://www.pph166.com/"),
models.Publisher(name="中国财经出版社",
address="北京",
city="北京",
state_province="北京",
country="中国",
website="http://cfeph.cfemg.cn/"),
models.Publisher(name="机械工业出版社",
address="上海",
city="上海",
state_province="上海",
country="中国",
website="http://www.cmpedu.com/"),
models.Publisher(name="新世纪出版社",
address="深圳",
city="深圳",
state_province="广东",
country="中国",
website="http://www.gdpg.com.cn/"),
models.Publisher(name="中国法制出版社",
address="南昌",
city="南昌",
state_province="江西",
country="中国",
website="http://www.zgfzs.com/"),
models.Publisher(name="人民邮电出版社",
address="南宁",
city="南宁",
state_province="广西",
country="中国",
website="https://www.ptpress.com.cn/"),
models.Publisher(name="中国农业出版社",
address="北京",
city="北京",
state_province="北京",
country="中国",
website="http://www.ccap.com.cn/"),
models.Publisher(name="人民卫生出版社",
address="厦门",
city="厦门",
state_province="福建",
country="中国",
website="http://www.pmph.com/"),
models.Publisher(name="石油工业出版社",
address="广东",
city="广东",
state_province="广东",
country="中国",
website="http://www.petropub.com/"),
])
# 批量插入Author表
models.Author.objects.bulk_create([
models.Author(name='ShiZhongyu'),
models.Author(name='SunDasheng'),
models.Author(name='LinDaiyu'),
models.Author(name='LinChong'),
models.Author(name='MaChao'),
models.Author(name='XieYanke'),
models.Author(name='TianBoguang'),
models.Author(name='YuanChengzhi'),
])
# 批量插入AuthorDetail表
models.AuthorDetail.objects.bulk_create([
models.AuthorDetail(
sex=0,
email="*****@*****.**",
address="深圳市",
birthday="1989-08-30",
author_id=1,
),
models.AuthorDetail(
sex=1,
email="*****@*****.**",
address="北京市",
birthday="1988-01-30",
author_id=2,
),
models.AuthorDetail(
sex=0,
email="*****@*****.**",
address="龙岩市",
birthday="1985-05-30",
author_id=3,
),
models.AuthorDetail(
sex=1,
email="*****@*****.**",
address="广东市",
birthday="1985-04-30",
author_id=4,
),
models.AuthorDetail(
sex=1,
email="*****@*****.**",
address="广西市",
birthday="1986-02-28",
author_id=5,
),
models.AuthorDetail(
sex=0,
email="*****@*****.**",
address="上海市",
birthday="1987-08-30",
author_id=6,
),
models.AuthorDetail(
sex=1,
email="*****@*****.**",
address="南京市",
birthday="1987-04-30",
author_id=7,
),
models.AuthorDetail(
sex=0,
email="*****@*****.**",
address="长沙市",
birthday="1986-06-30",
author_id=8,
),
])
# 批量插入Book表
models.Book.objects.bulk_create([
models.Book(title="鸟哥的Linux私房菜",
publication_date="1984-06-30",
price=36,
publisher_id=1),
models.Book(title="Linux内核设计与实现",
publication_date="1983-05-30",
price=60,
publisher_id=2),
models.Book(title="Linux入门到精通",
publication_date="1981-04-30",
price=45,
publisher_id=1),
models.Book(title="Python入门手册",
publication_date="1989-08-30",
price=64,
publisher_id=3),
models.Book(title="Python基础教程",
publication_date="1985-06-30",
price=37,
publisher_id=4),
models.Book(title="Python核心编程",
publication_date="1982-04-30",
price=52,
publisher_id=3),
models.Book(title="Go语言实战",
publication_date="1987-01-30",
price=49,
publisher_id=5),
models.Book(title="Go核心编程",
publication_date="1983-09-30",
price=20,
publisher_id=6),
models.Book(title="Go并发编程实战",
publication_date="1987-06-30",
price=30,
publisher_id=5),
models.Book(title="机器学习",
publication_date="1983-08-30",
price=50,
publisher_id=7),
models.Book(title="Linux就是这个范",
publication_date="1984-02-18",
price=26,
publisher_id=8),
models.Book(title="Php入门到精通",
publication_date="1982-01-30",
price=47,
publisher_id=9),
])
# 批量插入ManyToMang第三张表
for i in range(1, 13):
print(i)
book_obj = models.Book.objects.get(id=i)
import random
num_list = []
if len(num_list) == 2:
num_list[0] = ""
num_list[1] = ""
num = random.randint(1, 8)
num1 = random.randint(1, 8)
num_list.append(num)
if num == num1:
num1 = random.randint(1, 8)
num_list.append(num1)
num_list.append(num1)
book_obj.authors.add(*num_list)
return render(request, 'addata.html')
# ret = models.Employee.objects.all().values("id", "dept")
# print(ret)
from django.db.models import Avg
# ret = models.Employee.objects.values("dept").annotate(avg=Avg("salary")).values("dept","avg")
# print(ret)
# ret = models.Employee2.objects.values("dept_id").annotate(avg=Avg("salary")).values("dept__name","avg")
# print(ret)
# 查所有的员工和部门名称
# ret = models.Employee2.objects.values("name", "dept__name")
# print(ret)
#
# ret = models.Employee2.objects.select_related().values("name", "dept__name")
# print(ret)
#
# ret = models.Author.objects.select_related("books__title").values("name", "books__title")
# print(ret)
# print("=" * 120)
# ret = models.Author.objects.prefetch_related("books__title").values("name", "books__title")
# print(ret)
# 批量创建
# 有100个书籍对象
objs = [models.Book(title="沙河{}".format(i)) for i in range(1500)]
# 在数据库中批量创建, 10次一提交
models.Book.objects.bulk_create(objs, 10)
# models.Book.objects.all().delete()
def query(request):
# 记录的增删改查
# 1添加
# 添加数据记录 方式1
new_book = models.Book(
title='金瓶梅',
price=9.91,
# pub_date=datetime.datetime.now()
# 添加时间日期类型数据时可以是时间日期类型的数据,
# 也可以是字符串数据
pub_date='2022-02-02',
publish='32期出版社'
# 有默认值的或者可以为空的或者主键字段,都可以不用传值
)
# new_book.save()
# 添加方式2 create方法,create方法的返回值为 新添加的数据的模型类对象
# new_book = models.Book.objects.create(
# title='金瓶梅4',
# price=19.9,
# pub_date='2020-04-02',
# publish='32期出版社'
# )
# print(new_book.title) #金瓶梅4
# print(new_book.price) #19.9
# 批量添加
# obj_list = []
# for i in range(2):
# book_obj = models.Book(
# title=f'少年闰土{i}',
# # 和js的$(变量名)取值类似
# price=10 + i,
# pub_date=f'2022-04-1{i}',
# publish='32期出版社'
# )
# obj_list.append(book_obj)
#
# print(obj_list)
# # [<Book: Book object>, <Book: Book object>,
# # [<Book: 少年闰土0>, <Book: 少年闰土1>] models中加了 __str__魔术方法
# models.Book.objects.bulk_create((obj_list)) #bulk_create 批量添加
# 2 查询
# 01 查询所有
# book_objs = models.Book.objects.all() # #queryset 类似于列表
# print(book_objs)
# <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>,
#02 指定条件查询 方法1
# 结果为queryset类型数据
# book_objs = models.Book.objects.filter(id=4)
# print(book_objs)
# <QuerySet [<Book: 金瓶梅4>]>
# book_objs = models.Book.objects.filter()
# # filter没有加条件,和all一样的效果
# print(book_objs)
# <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>,
# book_objs = models.Book.objects.filter(id=100)
# print(book_objs)
# <QuerySet []>
#02 指定条件查询 方法2
# book_objs = models.Book.objects.get(id=4)
# ## 条件查找 结果为: 模型类对象
# print(book_objs)
# #金瓶梅4
# book_objs = models.Book.objects.get() #查所有
# # 但是get方法的查询结果有要求,有且只能有一条
# print(book_objs)
# book_objs = models.Book.objects.get(id=100) # 查询不到结果会报错 Book matching query does not exist.
# # 查询结果多于一条也会报错
# print(book_objs)
# get() returned more than one Book -- it returned 16!
# 3 删除 方法1
# models.Book.objects.filter(id=3).delete()
#queryset类型数据可以调用delete方法删除查询结果数据
# 方法2
# models.Book.objects.get(id=4).delete()
# 4 修改
# 修改方式1 通过queryset类型数据修改
# models.Book.objects.filter(id=5).update(
# price=20,
# title='读书'
# )
# models.Book.objects.get(id=5).update(
# price=30, #报错:模型类对象不能调用update方法
# )
# 'Book' object has no attribute 'update'
# 修改方式2 通过模型类对象来修改
# ret = models.Book.objects.get(id=5)
# ret.price = 30
# ret.title = '健身'
# ret.save()
# DatetimeField、DateField、TimeField这个三个时间字段，都可以设置如下属性
# (7)auto_now_add
# 配置auto_now_add=True，创建数据记录的时候会把当前时间添加到数据库。
#
# (8)auto_now
# 配置上auto_now=True，每次更新数据记录的时候会更新该字段，
# 标识这条记录最后一次的修改时间。
# 测试auto_now和auto_now_add两个参数
# 新添加的数据的模型类对象
# models.userinfo.objects.create(
# name='xx3',
# )
# models.userinfo.objects.filter(id=1).update(
# # ( #update不能触发自动更新时间的auto_now参数的作用,
# # # 如果用update方法来更新记录,并保存更新记录的时间,
# # 需要我们手动给该字段传入当前时间
# name='投资',
# b1 = datetime.datetime.now()
# )
# 这种save方式能够触发auto_now参数自动更新修改时间的动作
# ret = models.userinfo.objects.get(id=1)
# ret.name = '读书'
# ret.save()
# 基于双下划线的模糊查询
# 查询书名以少年开头的哪些书
# obj_list = models.Book.objects.filter(title__startswith='少年')
# #以什么开头
# print(obj_list)
# #<QuerySet [<Book: 少年闰土1>, <Book: 少年闰土2>,
# obj_list = models.Book.objects.filter(title__endswith='梅')
# #以什么结尾
# print(obj_list)
# # <QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>]>
# obj_list = models.Book.objects.filter(title__startswith='p')
# print(obj_list)
# <QuerySet [<Book: python少年闰土1>]>
# obj_list = models.Book.objects.filter(title__istartswith='p')
# #不区分大小写
# print(obj_list)
# # <QuerySet [<Book: python少年闰土1>, <Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(title__contains='th')
# #包含
# print(obj_list)
# # <QuerySet [<Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(title__icontains='th')
# #包含 不区分大小写
# print(obj_list)
# # <QuerySet [<Book: pytHon少年闰土1>, <Book: Python少年闰土2>]>
# obj_list = models.Book.objects.filter(price__gt=18) #大于
# print(obj_list)
# # <QuerySet [<Book: 健身>, <Book: 少年闰土9>]>
# obj_list = models.Book.objects.filter(price__gte=19) #大于等于
# print(obj_list)
# <QuerySet [<Book: 健身>, <Book: 少年闰土9>]>
# obj_list = models.Book.objects.filter(price__lt=10) #小于
# print(obj_list)
# #<QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>]>
# obj_list = models.Book.objects.filter(price__lte=10) #小于等于
# print(obj_list)
# QuerySet [<Book: 金瓶梅>, <Book: 金瓶梅>, <Book: 少年闰土0>]>
# obj_list = models.Book.objects.filter(price__in=[15,18,30])
# #价格等于15或者等于18或者等于30的书籍
# print(obj_list)
# #<QuerySet [<Book: 健身>, <Book: 少年闰土5>, <Book: 少年闰土8>]>
# obj_list = models.Book.objects.filter(price__range=[15,17])
# #价格大于等于15并且小于等于17, between and
# print(obj_list)
#<QuerySet [<Book: 少年闰土5>, <Book: 少年闰土6>, <Book: 少年闰土7>]>
# obj_list = models.Book.objects.filter(id=10,price=15)
# #逗号连接的查询条件就是and的关系
# print(obj_list)
# <QuerySet [<Book: 少年闰土5>]>
# obj_list = models.Book.objects.filter(pub_date__year='2020')
# #2020年的所有书籍
# print(obj_list)
# # <QuerySet [<Book: 少年闰土1>]>
# obj_list = models.Book.objects.filter\
# (pub_date__year='2020',pub_date__month='04')
# #2020年4月份的所有书籍
# print(obj_list)
# # <QuerySet [<Book: 少年闰土1>]>
# obj_list = models.Book.objects.filter(pub_date__year='2020',
# pub_date__month='04',
# pub_date__day='11')
# # 2020年4月11号的所有书籍 方法1
# print(obj_list)
# # # <QuerySet [<Book: 少年闰土1>]>
# obj_list = models.Book.objects.filter(pub_date = '2020-04-11')
# # # 2020年4月11号的所有书籍 方法2 推荐
# print(obj_list)
# # # <QuerySet [<Book: 少年闰土1>]>
# 1 all
# 2 filter
# 3 get
# 4 exclude 排除
# 返回结果为queryset类型数据,
# 通过objects控制器可以调用,queryset类型数据也能调用
# obj_list = Book.objects.exclude(id!=2)
# 不支持!=
# obj_list = Book.objects.exclude(id=2)
# # print(obj_list)
# obj_list = obj_list.filter(title='少年闰土4')
# print(obj_list)
# # <QuerySet [<Book: 少年闰土4>]>
# obj_list = obj_list.all()
# print(obj_list) # <QuerySet [<Book: 少年闰土4>]>
#
# obj_list = Book.objects.exclude(id=2).filter(title__contains='少年').exclude(id=7)
# print(obj_list)
#5 order_by 排序
# 返回结果为queryset类型数据,queryset类型数据可以调用这个方法
obj_list = Book.objects.all().order_by('id')
# 按照id升序排列
# print(obj_list)
# obj_list = Book.objects.all().order_by('-id')
# # 按照id降序排列
# print(obj_list)
# '''select * from app01_book order by id desc;'''
# obj_list = Book.objects.all().order_by('price','-id')
# #按照价格升序排列,价格相同的按照id降序排列
# print(obj_list)
# 6 reverse() 反转
# 翻转必须在排序数据的基础上
# 返回结果为queryset类型数据,queryset类型数据可以调用这个方法
# obj_list = Book.objects.all().order_by('-id').reverse()
# print(obj_list)
#7 count
#queryset类型的数据来调用，返回数据库中匹配查询(QuerySet)的对象数量。
# queryset类型数据可以调用这个方法,返回值为数字
# obj_list = Book.objects.all().count()
# print(obj_list) #8
# 8 9 first\last
# 返回第一条/最后一条记录
# queryset类型数据可以调用这个方法,返回值为模型类对象,不是queryset类型
# obj_list = Book.objects.all().first()
# print(obj_list) #金瓶梅
# obj_list = Book.objects.all().last()
# print(obj_list) #少年闰土6
# obj_list = Book.objects.all()[0] #第一条
# print(obj_list) #金瓶梅
# 10 exists
# 判断查询结果是有数据 返回True 或者False
# queryset类型数据可以调用这个方法
# obj_list = Book.objects.all().exists()
# print(obj_list) #True
#判断是否有数据的效率高,只找一条记录就返回 limit 1
# 11 values ***
# 可以获取指定字段数据
# objects可以调用, queryset也能调用,
# 返回结果还是queryset,内容为一个个字典数据
obj_list = Book.objects.values('title', 'price')
# print(obj_list)
# <QuerySet [{'title': '金瓶梅', 'price': Decimal('9.90')},
# {'title': '健身', 'price': Decimal('30.00')}
# obj_list = Book.objects.filter(id=5).values('title','price')
# print(obj_list)
# <QuerySet [{'title': '健身', 'price': Decimal('30.00')}]>
#12 values_list ***
# 可以获取指定字段数据,返回结果还是queryset,内容为一个个元组数据
# obj_list = Book.objects.values_list('title','price')
# print(obj_list)
# <QuerySet [('金瓶梅', Decimal('9.90')), ('健身', Decimal('30.00')),
# obj_list = Book.objects.filter(id=5).values_list('title','price')
# print(obj_list)
# <QuerySet [('健身', Decimal('30.00'))]>
#13 distinct 去重
# 一般配合values和values_list来使用
obj_list = Book.objects.values('price').distinct()
print(obj_list)
# <QuerySet [{'price': Decimal('9.90')}, {'price': Decimal('30.00')}, {'price': Decimal('11.00')}, {'price'
# : Decimal('12.00')}, {'price': Decimal('13.00')}, {'price': Decimal('15.00')}, {'price': Decimal('16.00')
# }]>
return HttpResponse('ok')
#外部文件使用django的models,需要配置django环境
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "singletablehw.settings")
import django
django.setup()
from app01 import models
import datetime
obj_list = []
for i in range(1,10):
obj = models.Book(
title='葵花宝典第%s式'%i,
price=20 + i,
pub_date='198%s-11-11 00:00:00'%i,
# pub_date=datetime.datetime.now(),
publish= '吴老板出版社' if i < 5 else '太白出版社',
)
obj_list.append(obj)
models.Book.objects.bulk_create(obj_list)
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "django_orm02.settings")
import django
django.setup()
from app01 import models
#django外部脚本调用django环境来操作
# 批量创建100条数据到书籍表
obj_lsit = []
for i in range(100):
book_obj = models.Book(
title=f'白洁{i}',
price=i,
publishDate='2020-11-11',
publishs_id=1,
)
obj_lsit.append(book_obj)
models.Book.objects.bulk_create(obj_lsit)
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "days70_dj.settings")
import django
django.setup()
from app01 import models
data_list = [models.Book(title='第 {0} 本书'.format(i)) for i in range(100)]
models.Book.objects.bulk_create(data_list)
import os
import sys
if __name__ == '__main__':
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'mysiteday71.settings')
import django
django.setup()
from app01 import models
# ret = models.Employee.objects.all().values('name', 'department')
# print(ret)
# from django.db.models import Avg
# ret = models.Employee.objects.values('department').annotate(avg=Avg('salary')).values('department', 'avg')
# print(ret)
# ret = models.Employee.objects.values('department_id').annotate(avg=Avg('salary')).values('department__name', 'avg')
# print(ret)
# ret = models.Author.objects.select_related().values('name', 'book__title')
# print(ret)
# print('='*120)
# ret = models.Author.objects.prefetch_related().values('name', 'book__title')
# print(ret)
# 批量创建
# 有100个书籍对象
obj = [models.Book(title='沙河{}'.format(i)) for i in range(100)]
models.Book.objects.bulk_create(obj, 10)
import django
django.setup()
# 下面就可以使用Django的环境了
from app01 import models
ret = models.Author.objects.filter(name__contains="刘")
print(ret)
ret = models.Person.objects.filter(birthday__year=2019)[0]
ret = ret.name
print(ret)
ret = models.Book.objects.filter(price__gt=50)
print(ret)
ret = models.Book.objects.all().values_list("publisher__name")
print(ret)
# distinct 对QuerySet去重
print(ret.distinct())
# 将所有的书按照价格倒叙排序
ret = models.Book.objects.all().order_by("price").values_list("title")
print(ret)
ret = models.Book.objects.filter(title="三体").values_list("author__name")
print(ret)
# 批量创建，创建20个书籍对象
objs = [models.Book(title="围城{}".format(i)) for i in range(20)]
# 在数据库中批量创建，5次一提交
models.Book.objects.bulk_create(objs, 5)
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "DemoPaging.settings")
import django
django.setup()
from app01 import models
# for i in range(500):
# 效率低的写法
# models.Book.objects.create(title="跟老男孩学xx{}".format(i), price=i)
# 高效的写法
# 1. 先创建500个书籍对象
book_list = [
models.Book(title="海子的诗{}".format(i), price=i) for i in range(500)
]
# # 2. 批量提交到数据库,
models.Book.objects.bulk_create(book_list)
import os
if __name__ == '__main__':
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "advance.settings")
import django
django.setup()
from app01 import models
objs = [models.Book(name='和我学python{}'.format(i)) for i in range(1500)]
models.Book.objects.bulk_create(objs, 10)
