weixin_34306593
weixin_34306593

python的Web框架，Django模型系统二，模型属性，及数据库进阶查询

python的Web框架，Django模型系统二，模型属性，及数据库进阶查询

原始数据接上篇文章来操作。可能需要查看后才能懂。点击这里查看

1.常用的模型字段类型

官方文档：https://docs.djangoproject.com/en/2.1/ref/models/fields/#field-types

定义的模型中，类名对应的表名，类属性对应的表的字段，我们在上节内容有说过，可以查看。这里我们详细了解。 

python的Web框架，Django模型系统二，模型属性，及数据库进阶查询_第1张图片

 

django和mysql的对应类型，models.Model下的方法

django类型 映射到mysql类型
IntegerField : 整型 映射到数据库中的int类型。
CharField: 字符类型 映射到数据库中的varchar类型，通过max_length指定最大长度。
TextField: 文本类型 映射到数据库中的text类型。
BooleanField: 布尔类型 映射到数据库中的tinyint类型，在使用的时候，传递True/False进去。如果要可以为空，则用NullBooleanField。
DateField: 日期类型 没有时间。映射到数据库中是date类型在使用的时候，可以设置DateField.auto_now每次保存对象时，自动设置该字段为当前时间。设置DateField.auto_now_add当对象第一次被创建时自动设置当前时间。
DateTimeField: 日期时间类型 映射到数据库中的是datetime类型，在使用的时候，传递datetime.datetime()进去。

2.字段的常用参数

官方文档：https://docs.djangoproject.com/en/2.1/ref/models/fields/#field-options

field常用参数

参数名 作用
primary_key: 指定是否为主键。
unique: 指定是否唯一。
null: 指定是否为空，默认为False。
blank: 等于True时form表单验证时可以为空，默认为False。
default: 设置默认值。
DateField.auto_now: 每次修改都会将当前时间更新进去，只有调用，QuerySet.update方法将不会调用。这个参数只是Date和DateTime以及TimModel.save()方法才会调用e类才有的。
DateField.auto_now_add: 第一次添加进去，都会将当前时间设置进去。以后修改，不会修改这个值
主键的设置
第一种方式设置主键，指定int类型，设置为主键，使用自增长。
id = models.IntegerField(primary_key=True, auto_created=True)

第二种方式：使用AutoField方法，这个方法是自增长且为int类型
id = models.AutoField(primary_key=True使用AutoField方法，这个方法是自增长且为int类型)

 

unique设置唯一，注意的事项
1 qq = models.CharField(max_length=20, unique=True, null=True)
 当你设置的这个字段是唯一了，就代表必须和其他的不一样，但是有的时候用户没有提供，可以不填的，就可以为空，不然就会出错

3.常用查询

管理器理解

objects是Students的对象，是django.db.models.manager.Manager的一个实例。

>>>Students.objects

 

QuerySet

表示数据库中对象的集合，可以等同于select的语句。它是惰性的。

单条数据查询：

排序：默认按照主键id排序，可以通过模型中的_meta属性设置排序问题。

first 获取第一条，返回的是一个对象，默认按照主键id排序
>>>Students.objects.first()

 

last 获取最后一条，默认按照主键id排序
>>>Students.objects.last()

 

get(**kwargs) 根据给定的条件，获取一个对象，如果有多个对象符合，则会报错。
>>>Students.objects.get(name='刘一')

 

多条数据查询

all() 获取所有记录，返回的是QuerySet
>>> Students.objects.all() 
, , , , , , , , , ]>

 

filter(**kwargs)：过滤，根据给定的条件，获取一个过滤后的QuerySet，多个条件的QuerySet语句是and连接
>>>res = Students.objects.filter(sex=1,age=16)

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE (`teacher_students`.`age` = 16 AND `teacher_students`.`sex` = 1)

 

exclude(**kwargs) 排除，和filter使用方法一致，作用相反，根据给定的条件，获取一个排除后的QuerySet，可以多个条件
>>>res = Students.objects.exclude(sex=1)

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE NOT (`teacher_students`.`sex` = 1)

 

Q：或者，多条件查询，相当于MySQL中的or，这个方法需要单独导入

需要导包

from django.db.models import Q

 

语法: Q(*args) |

>>> res =Students.objects.filter(Q(age=0)|Q(age=1))
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE (`teacher_students`.`age` = 0 OR `teacher_students`.`age` = 1)

 

values(*fields)，字段查询。可以多个查询，返回一个QuerySet，返回一个字典列表，而不是数据对象
复制代码 
>>> res = Students.objects.values('name')

>>>print(res.query)
SELECT `teacher_students`.`name` FROM `teacher_students`

>>>res
'name': '小明'}, {'name': 'XiaoHong'}, {'name': '王五'}, {'name': '赵柳'}, {'name': '张三'}, {'name': '李思'}, {'name': '赵柳'}, {'name': '孙奇'}, {'name': 'ABC'}, {'name': 'abc'}, {>

>>>res[0]['name']
'小明'


#可以多条查询 res = Students.objects.values('name','age') 
#可以增加过滤 res = Students.objects.values('name').filter(age=0)
复制代码

 

only(*field) 返回QuerySet,是一个对象列表，不是字典，而且only一定包含主键字段。此方法用的更多些。

因为是一个对象列表，所以可以有后期的其他操作，我们可以指定很少的字段后再后期继续获取，效率较高，还可以动态的拿到其他数据。

复制代码 
>>> res = Students.objects.only('name')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name` FROM `teacher_students`
#会默认拿到id主键

>>> res[0].c_time
datetime.datetime(2019, 2, 26, 8, 4, 57, 955584, tzinfo=)
#没有获取这个字段也一样可以拿到，这就是only的作用

#其他写法：
res = Students.objects.only('name','age').filter(age=16)
复制代码

 

defer(*fields) 返回一个QuerySet，和only一样用法，作用相反
复制代码 
>>>res = Students.objects.defer('c_time','age')

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone` FROM `teacher_students`

>>>res
 , , , , , , , , , ]>
 
 >>>res[0].c_time
 datetime.datetime(2019, 2, 26, 8, 4, 57, 955584, tzinfo=)
复制代码

 

排序

order_by(*fields)：根据给定的字段来排序,默认是正序，在字段名前加上-，会变成反序，可以多字段排序。

正序

复制代码 
>>>res = Students.objects.order_by('c_time')

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY `teacher_students`.`c_time` ASC

#可以配合only使用:
#res = Students.objects.order_by('c_time').only('name')
复制代码

 

反序,在需要的条件前面加上'-'

>>>res = Students.objects.order_by('-c_time')

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY `teacher_students`.`c_time` DESC

 

Lower：按照小写进行排序,创建复杂查询的时候用。

Lower这个方法需要导包

from django.db.models.functions import Lower

 

正序

复制代码 
>>> res = Students.objects.order_by(Lower('name'))

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY LOWER(`teacher_students`.`name`) ASC
#LOWER是数据库本身的功能，它把字段的内容(`teacher_students`.`name`) 变成大写排序。

>>> res
 , , , , , , , , , ]>
复制代码

 

倒序

复制代码 
>>> res = Students.objects.order_by(Lower('name').desc())

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` ORDER BY LOWER(`teacher_students`.`name`) DESC

>>> res
 , , , , , , , , , ]>
复制代码

 

切片

等同于MySQL里面的LIMIT,OFFSET,数量量和偏移量，和python的列表切片用法相似，不支持负索引，数量量大时不用步长
***切片过后，不再支持附加的过滤条件与排序，条件需要放在切片之前。
复制代码 
>>>res = Students.objects.all()[:5]

>>>print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students`  LIMIT 5

>>>res = Students.objects.all()[2:6]

>>>print(res.query) #打印出他的sql语句
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students`  LIMIT 4 OFFSET 2


>>>res = Students.objects.all()[::2]

>>>res
[, , , ]
 #得到的直接是一个list列表，不是一个对象，不能再有后续的操作
复制代码

 

常用查询条件 ，一般使用双下划线 '__'

支持 filter、exclude、get……, LINK子句
exact：精准匹配，对象列表
>>> res = Students.objects.filter(id__exact=4) 
#__exact也可以不写，默认的不用写

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`id` = 4

 

iexact:不区分大小写，对象列表
复制代码 
>>> res = Students.objects.filter(name__iexact='abc')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE abc

>>> res
, ]>
复制代码

 

contains 包含
复制代码 
>>> res = Students.objects.filter(name__contains='abc')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY %abc%

>>> res
 ]>
复制代码

 

icontains 包含,不区分大小写
>>> res = Students.objects.filter(name__icontains='abc')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE %abc%

 

in：在……里面找
>>> res = Students.objects.filter(name__in=['abc','ABC','小明'])

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IN (abc, ABC, 小明)

 

range：范围，在一个范围内找。
复制代码 
>>> res = Students.objects.filter(age__range=(14,20))

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` BETWEEN 14 AND 20

>>> res
 , , , , ]>
复制代码

 

gt:大于，gte:大于等于
复制代码 
#大于 方法
>>> res = Students.objects.filter(age__gt=18)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` > 18


#大于等于 方法
>>> res = Students.objects.filter(age__gte=18)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` >= 18
复制代码

 

lt:小于,lte：小于等于
复制代码 
#小于方法
>>> res = Students.objects.filter(age__lt=18)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` < 18


#小于等于 方法
>>> res = Students.objects.filter(age__lte=18)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`age` <= 18
复制代码

 

startswith :以……开头,大小写敏感，区分大小写
>>> res = Students.objects.filter(name__startswith='小')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY 小%

 

istartswith :以……开头,不区分大小写
>>> res = Students.objects.filter(name__istartswith='小')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE 小%

 

endswith :以……结尾,区分大小写
>>> res = Students.objects.filter(name__endswith='小')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE BINARY %小

 

iendswith :以……结尾,不区分大小写
>>> res = Students.objects.filter(name__iendswith='小')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` LIKE %小

 

isnull：返回True，False，BOOL值，对应MySQL中的IS NULL、IS NOT NULL
True/False; 做 IF NULL/IF NOT NULL 查
复制代码 
>>> res = Students.objects.filter(name__isnull=True)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IS NULL

>>> res = Students.objects.filter(name__isnull=False)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time` FROM `teacher_students` WHERE `teacher_students`.`name` IS NOT NULL
复制代码

 

快速查找方法表
类型 描述
exact 精确匹配: polls.get_object(id__exact=14).
iexact 忽略大小写的精确匹配: polls.objects.filter(slug__iexact="foo") 匹配 foo, FOO, fOo, 等等.
contains 大小写敏感的内容包含测试: polls.objects.filter(question__contains="spam") 返回question 中包含 "spam" 的所有民意测验.(仅PostgreSQL 和 MySQL支持. SQLite 的LIKE 语句不支持大小写敏感特性. 对Sqlite 来说, contains 等于 icontains.)
icontains 大小写不敏感的内容包含测试:
gt 大于: polls.objects.filter(id__gt=4).
gte 大于等于.
lt 小于.
lte 小于等于.
ne 不等于.
in 位于给定列表中: polls.objects.filter(id__in=[1, 3, 4]) 返回一个 polls 列表(ID 值分别是 1或3或4).
startswith 大小写敏感的 starts-with: polls.objects.filter(question__startswith="Would"). (仅PostgreSQL 和MySQL支持. SQLite 的LIKE 语句不支持大小写敏感特性. 对Sqlite 来说,startswith 等于 istartswith)
endswith 大小写敏感的 ends-with. (仅PostgreSQL 和 MySQL)
istartswith 大小写不敏感的 starts-with.
iendswith 大小写不敏感的 ends-with.
range 范围测试: polls.objects.filter(pub_date__range=(start_date, end_date)) 返回 pub_date 位于 start_date 和 end_date (包括)之间的所有民意测验
year 对 date/datetime 字段, 进行精确的 年 匹配: polls.get_count(pub_date__year=2005).
month 对 date/datetime 字段, 进行精确的 月 匹配:
day 对 date/datetime 字段, 进行精确的 日 匹配:
isnull True/False; 做 IF NULL/IF NOT NULL 查询: polls.objects.filter(expire_date__isnull=True).

聚合

需要导包

from django.db.models import Count, Avg, Max, Min, Sum

 

通过管理器的aggregate方法

Count 统计与count（首字母小写）
复制代码 
小写count
>>> Students.objects.filter(name__startswith='小').count()
1

大写Count
>>> Students.objects.filter(sex=1).aggregate(age_count=Count('age'))
{'age_count': 7}
复制代码
Avg 平均数

返回一个字典，需要我们给一个key，然后生成一个字典。

>>> Students.objects.filter(sex=1).aggregate(age_avg=Avg('age'))
{'age_avg': 17.4286}

 

Max 最大
>>> Students.objects.filter(sex=1).aggregate(age_max=Max('age'))
{'age_max': 29}

 

Min 最小
>>> Students.objects.filter(sex=1).aggregate(age_min=Min('age'))
 {'age_min': 5}

 

Sum 求和
>>> Students.objects.filter(sex=1).aggregate(age_sum=Sum('age'))
{'age_sum': 122}

 

分组

需要配合聚合、values、Count一起使用

通过找到字段数据后，然后对这个字段的信息进行聚合后，再分组

复制代码 
拿到字段为sex的，然后对sex这个字段来统计聚合后，再分组
>>> Students.objects.values('sex').annotate(num=Count('sex'))
 'sex': 1, 'num': 7}, {'sex': 0, 'num': 4}]>
 
>>> Students.objects.values('age').annotate(num=Count('age'))
 'age': 16, 'num': 2}, {'age': 24, 'num': 1}, {'age': 22, 'num': 1}, {'age': 23, 'num': 1}, {'age': 17, 'num': 1}, {'age': 19, 'num': 2}, {'age': 29, 'num': 1}, {'age': 5, 'num': 1}, {'age': 6, 'num': 1}]>
 
 
>>> res = Students.objects.values('age').annotate(num=Count('age'))

>>>print(res.query)
SELECT `teacher_students`.`age`, COUNT(`teacher_students`.`age`) AS `num` FROM `teacher_students` GROUP BY `teacher_students`.`age` ORDER BY NULL
复制代码

 

4.表关系的实现

python的Web框架，Django模型系统二，模型属性，及数据库进阶查询_第2张图片

MySQL表关系的创建：在Django中创建模型来生成MySQL中表的关系。

OneToOne：一对一的表关系，OneToOneField方法

使用主键关联主键。模型类操作。

例子如上面内容所写
复制代码 
 1 from django.db import models
 2 
 3     学生主表（一）
 4     class Students(models.Model):
 5         name = models.CharField(max_length=20)
 6         age = models.SmallIntegerField(default=0)
 7         sex = models.SmallIntegerField(default=1)
 8         qq = models.CharField(max_length=20, unique=True, null=True)
 9         phone = models.CharField(max_length=20, unique=True, null=True)
10         c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
11         e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
12     
13         #__str__代码,表示输出格式化，是为了在ipython调试中方便查看数据，对数据库不造成任何影响，不用做数据库迁移
14         def __str__(self):
15             return '%s-%s' % (self.name, self.age)
16 
17     学生详情表（一）
18     Class StudentsDetail(models.Model):
19         num = models.CharField(max_length=20, default='')
20         college = models.CharField(max_length=20, default='')
21         student = models.OneToOneField('Students', on_delete=models.CASCADE)
22         
23         
24         一对一的关联操作解析：'OneToOneField'
25         student = models.OneToOneField('Students', on_delete=models.CASCADE)
26         第一个参数是需要关联的表，需要字符串操作，第二个参数'on_delete=models.CASCADE'表示级联操作，如果主表有信息删除则此表信息也会跟着删除。
复制代码

 

OneToMany：一对多的表关系，ForeignKey方法

复制代码 
from django.db import models

    学生主表(多)
    class Students(models.Model):
        name = models.CharField(max_length=20)
        age = models.SmallIntegerField(default=0)
        sex = models.SmallIntegerField(default=1)
        qq = models.CharField(max_length=20, unique=True, null=True)
        phone = models.CharField(max_length=20, unique=True, null=True)
        c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
        e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
        grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
        
        
        多对一关联解析：'ForeignKey'：设置外键关联Grade表
        grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
        'on_delete=models.SET_NULL'：(必须带一个null=True)代表如果关联的表对应数据被删除，则显示NULL，不会被级联删除(如果班级被删除，学生则还在，所以不能级联)
    
    班级表（一）
    class Grade(models.Model):
        num = models.CharField(max_length=20)
        name = models.CharField(max_length=20)
复制代码

 

ManyToMany：多对多的表关系，ManyToManyField

只有一个字段的多对多：（简单的多对多）
复制代码 
 1 from django.db import models
 2 
 3     学生主表(多)
 4     class Students(models.Model):
 5         name = models.CharField(max_length=20)
 6         age = models.SmallIntegerField(default=0)
 7         sex = models.SmallIntegerField(default=1)
 8         qq = models.CharField(max_length=20, unique=True, null=True)
 9         phone = models.CharField(max_length=20, unique=True, null=True)
10         c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
11         e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
12         grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
13         
14         
15     课程表(多)    
16     class Course(models.Model):
17         name = models.CharField('课程名称', max_length=20)
18         students = models.ManyToManyField('Students')
19 
20 #当你的另外一张表里面仅仅只有两个字段的时候（id+外键），Django会自动创建中间表，不需要我们自己来创建。
复制代码

 

多张表的多对多，复杂，通过ManyToMany(多对多表)和ForeignKey(外键)来实现。
复制代码 
 1 from django.db import models
 2 
 3     学生主表(多)
 4     class Students(models.Model):
 5         name = models.CharField(max_length=20)
 6         age = models.SmallIntegerField(default=0)
 7         sex = models.SmallIntegerField(default=1)
 8         qq = models.CharField(max_length=20, unique=True, null=True)
 9         phone = models.CharField(max_length=20, unique=True, null=True)
10         c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
11         e_time = models.DateTimeField(verbose_name='编辑时间', auto_now=True)
12         grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
13         
14         
15     课程表(多)    
16     class Course(models.Model):
17         name = models.CharField('课程名称', max_length=20)
18         students = models.ManyToManyField('Students',through='Enroll')
19         
20     报名表(多)
21     class Enrloo(models,Model):
22         student = models.ForeignKey('Students',on_delete=models.CASCADE)
23         student = models.ForeignKey('Students',on_delete=models.CASCADE)
24         pay = models.IntegerField('缴费金额', default=0)
25         c_time = models.DateTimeField('报名时间', auto_now_add=True)
复制代码

 

使用报名表的两个外键把学生表和报名表关联起来，来达到多对多的方法，但是想要学生表直接访问到课程表，就需要在ManyToMany的参数中设置好两张表的关联。('多对多的表',through=来源的表)

 

 

创建关系的5张表汇总代码如下。

复制代码 
 1 ↓↓↓最后的全部代码参考↓↓↓
 2 from django.db import models
 3 
 4 # Create your models here.
 5 
 6 # 学生表
 7 class Students(models.Model):
 8     name = models.CharField(max_length=20)
 9     age = models.SmallIntegerField(default=0)
10     sex = models.SmallIntegerField(default=1)
11     qq = models.CharField(max_length=20, unique=True, null=True)
12     phone = models.CharField(max_length=20, unique=True, null=True)
13     c_time = models.DateTimeField(verbose_name='创建时间', auto_now_add=True)
14     e_time = models.DateTimeField(verbose_name='修改时间', auto_now=True)
15     grade = models.ForeignKey('Grade', on_delete=models.SET_NULL, null=True)
16 
17     def __str__(self):
18         return '%s-%s' % (self.name, self.age)
19 
20 
21 # 学生详情表
22 class StudentsDetail(models.Model):
23     num = models.CharField(max_length=20, default='')
24     college = models.CharField(max_length=20, default='')
25 
26     # 创建一对一需要创建的第一个参数是需要关联的表，第二个参数是主表有信息删除则此表信息也会跟着删除。
27     student = models.OneToOneField('Students', on_delete=models.CASCADE)
28 
29 
30 # 年级表
31 class Grade(models.Model):
32     num = models.CharField(max_length=20)
33     name = models.CharField(max_length=20)
34 
35 
36 # 课程表
37 class Course(models.Model):
38     name = models.CharField(max_length=20)
39     student = models.ManyToManyField('Students', through='Enroll')
40 
41 
42 # 报名表
43 class Enroll(models.Model):
44     student = models.ForeignKey('Students', on_delete=models.CASCADE)
45     course = models.ForeignKey('Course', on_delete=models.CASCADE)
46     pay = models.IntegerField('缴费金额', default=0)
47     c_time = models.DateTimeField('报名时间', auto_now_add=True)
复制代码

 

输出的结果通过工具查看他的导向图：

python的Web框架，Django模型系统二，模型属性，及数据库进阶查询_第3张图片

 

sqlmigrate 从迁移获取sql语句：获取创建表的sql语句

>>> python manage.py sqlmigrate teacher 0001

解析： teacher:appname        0001：Django的迁移执行文件

 

参数 作用
on_delete=models.CASCADE 级联关系，级联的表对应的数据删除，此表的对应的数据就删除，保证同步删除。
on_delete=models.SET_NULL (必须带一个null=True) 代表如果关联的表对应数据被删除，则显示NULL，不会被级联删除(如果班级被删除，学生则还在，所以不能级联)

关联表的数据操作

One-To-Many：一对多and多对一

正向的增删改查：

一个模型如果定义了一个外键字段，通过这个模型的操作外键就是正向。

现在我们开始操作数据库：

首先给年级表teacher_grade表增加几条数据

id num name
1 33期 django框架
2 34期 爬虫
以下代码为清除数据后的新表，代码是和前面的有关联的，变量和前面的有关。
赋值增加：通过外键字段得到关联表的数据

第一种方法：通过赋值方式添加数据，使用获取到的关联表的数据，通过本表的外键接受数据，然后保存即可。

复制代码 
 通过获取到的数据，赋值给当前表的外键字段，然后保存。
 
 # 先拿到Grade的一条数据
 >>> g1 = Grade.objects.first()
 
 # 获取一个Students的空对象
 >>> s = Students()
 
 # 给对象添加一个name字段的数据
 >>> s.name = '张三'
 
 # 把g1的数据复制给Students的grade的字段，然后得到数据。
 >>> s.grade = g1
 
 # 保存
 >>> s.save()
复制代码

 

第二种方法：通过外键字段得到关联表的数据，用对象的外键字段名接受关联表的数据(id获取)

复制代码 
>>> s2 = Students(name='李四')

>>> g2 = Grade.objects.last()

# 用对象的外键字段名接受关联表的数据，需要是关联表的主键id
>>> s2.grade_id = g2.id

>> sa.save()
复制代码

 

更新和修改

也可以通过赋值来操作

# 把对象的外键grade字段拿来接受g2的对象数据，以达到修改
>>> s.grade = g2

>>> s.save()

 

删除外键数据
# 通过赋值None来操作
>>> s.grade = None

>>> s.save()

 

查询

# 通过外键去拿到关联的数据
>>> s2.grade.name
'爬虫'

 

反向的增删改查

一个模型被另外一个模型的外键关联，通过这个模型对关联他的这个模型操作就是反向。

通过被关联表名的小写加上set来操作。管理器范式(小写_set)
增加
#在创建的同时，也直接把g2的对象数据一起增加了，此方法立刻执行
>>> g2.students_set.create(name='王五')
 

#把已有的对象通过add方法增加关联的数据，此方法立刻执行，如果本身自带了数据，则自动修改为本对象的数据
>>> g2.students_set.add(s)

 

查询
>>> g2.students_set.all()
 , , ]>
 
#查询的所有方法都可以使用，这里只做一个例子

 

删除
#删除单条
>>> g2.students_set.remove(s, s2)

#删除所有
>>> g2.students_set.clear()

 

set方法,接受对象列表，此方法是先执行clear后，再执行set添加。

把本来有的对象删除后，再添加新的对象

# 获取对象后，添加到本对象的表中
>>> g3.students_set.set([s, s2])

>>> g3.students_set.all()

 

通过本表的外键查询关联表的关于本表的数据

通过学生表查询年级表的所有学生，用外键字段加上__和关联表的字段名, 字段查询，不能全部查询

复制代码 
# 使用本表的外键查询('外键'+'__'+'关联表字段名')

>>> res = Students.objects.filter(grade__name='爬虫')

>>> res
, , ]>

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_grade` ON (`teacher_students`.`grade_id` = `teacher_grade`.`id`) WHERE `teacher_grade`.`name` = 爬虫
复制代码

 

Many-To-Many：多对多

多对多的两端都可以获得自动API去访问，访问的原理和一对多的反向有点类似，但是有一个不同的地方是多对多的模型使用的是本字段的属性名，而反向的是使用原始模型的小写加上set。下面我们来看怎么操作。

指定了中间表后，add、remove、set都不能用，必须用中间表。

首先增加几个课程数据(Course)来实现例子：

id name
1 pyton全栈
2 Java全栈
3 English

查看一下当前Students表数据

id name age sex qq phone c_time e_time grade_id
1 张三 0 1     2019-02-28 11:09:52.462364 2019-02-28 11:34:21.636189 2
2 李四 0 1     2019-02-28 11:18:47.456735 2019-02-28 11:18:47.456806 2
3 王五 0 1     2019-02-28 11:52:15.526063 2019-02-28 11:52:15.526134 null

add、remove、set都是没有指定中间表(through='Enroll')的时候才可以使用，不能使用用在对多的字段，当他指定这个的时候，就不能使用。

# 把创建出来的Course对象获取到变量中得到c1, c2, c3
>>> c1,c2,c3 = Course.objects.all() 

# 把创建出来的Students对象获取到变量中得到s1, s2, s3
>>> s1,s2,s3 = Students.objects.all()

 

增加
复制代码 
# 获取一个空对象
>>> e = Enroll()

# 把c1的对象赋值给Enroll的这个对象
>>> e.course = c1

# 把s1的对象赋值给Enroll的这个对象
>>> e.student = s1

>>> e.save()

#用两个外键字段名接受 关联表对象的数据。然后保存，可以得到一条外键关联的数据。
复制代码

 

结果得到的Enroll表数据为：

id pay c_time course_id student_id
1 0 2019-03-01 04:18:12.193959 1 1 
#用外键字段名id接受关联的对象id
>>> e.course_id = c2.id

>>> e.student_id = s2.id

>>> e.save()

 

结果到的Enroll表为：

id pay c_time course_id student_id
1 0 2019-03-01 04:18:12.193959 1 1
2 0 2019-03-01 04:24:53.105775 2 2

create方法创建，直接操作数据库

# 使用creat方法可以一起指定外键，然后创建
>>> Enroll.objects.create(sudent=s1,course=c3)

 

表中ManyToMany方法的应用。
#创建表的时候的代码解析：
student = models.ManyToManyField('Students', through='Enroll')
#Course表中的的字段，并不会在数据库中创建，而是django中需要配置的管理器。他可以很方便的在查询中起到作用。

 

我们来应用这个管理器，他可以很方便的查询到我们需要的数据，不是一个字段,我们可以在不使用第三张表(Enroll表)介入的时候，让Students和Course两个相互访问。

复制代码 
# 在course表中，使用的ManyToMany是一个管理器
>>> c1.student
.ManyRelatedManager at 0xaff763ec>

# 查找c1下面的所有学生
>>> c1.student.all()
]>

# 查找学生报名的所有课程
>>> s1.course_set.all()
 ]>
复制代码

 

One-To-One 一对一

增加
>>> sd = StudentsDetail.objects.create(num='20190301001', college='家里蹲', student=s1)

>>> sd

 

查询
>>> sd.student


>>> sd.student.name
'张三'

 

在一对一的关系中，可以通过关联表的模型名的小写（是对象，不是管理器），来拿到需要的数据,没有_set

>>> s1.studentsdetail


>>> s1.studentsdetail.num
'20190301001'

 

跨表查询

跨模型的相关字段的字段名，并且用双下划綫'__'去分割，直到达到想要获取的字段位置。

通过例子来查看如何跨表查询

查询男生都报名了什么课程：

# 用相关联的字段名+'__'关联表的字段名
>>> res = Course.objects.filter(student__sex=1)

>>> print(res.query)
SELECT `teacher_course`.`id`, `teacher_course`.`name` FROM `teacher_course` INNER JOIN `teacher_enroll` ON (`teacher_course`.`id` = `teacher_enroll`.`course_id`) INNER JOIN `teacher_students` ON (`teacher_enroll`.`student_id` = `teacher_students`.`id`) WHERE `teacher_students`.`sex` = 1

 

反向查询:用对应的模型名的小写。

查询所有报名python课程的学员：

复制代码 
#模糊查询用contains

>>> res = Students.objects.filter(course__name__contains='python')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) WHERE `teacher_course`.`name` LIKE BINARY %python%
复制代码

 

and关系

查询所有报名英语的33期的学员：

>>> res = Students.objects.filter(course__name__contains='englist',grade__num__contains='33期')

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) INNER JOIN `teacher_grade` ON (`teacher_students`.`grade_id` = `teacher_grade`.`id`) WHERE (`teacher_course`.`name` LIKE BINARY %englist% AND `teacher_grade`.`num` LIKE BINARY %33期%)

 

查询所有缴费金额小于3000的学员：
>>> res = Students.objects.filter(enroll__pay__lt=3000)

>>> print(res.query)
SELECT `teacher_students`.`id`, `teacher_students`.`name`, `teacher_students`.`age`, `teacher_students`.`sex`, `teacher_students`.`qq`, `teacher_students`.`phone`, `teacher_students`.`c_time`, `teacher_students`.`e_time`, `teacher_students`.`grade_id` FROM `teacher_students` INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) WHERE `teacher_enroll`.`pay` < 3000.0

 

查询所有报名python的班级有哪些
>>> res = Grade.objects.filter(students__course__name__contains='python')
通过学生表去查课程名称之后，

>>> print(res.query)
SELECT `teacher_grade`.`id`, `teacher_grade`.`num`, `teacher_grade`.`name` FROM `teacher_grade` INNER JOIN `teacher_students` ON (`teacher_grade`.`id` = `teacher_students`.`grade_id`) INNER JOIN `teacher_enroll` ON (`teacher_students`.`id` = `teacher_enroll`.`student_id`) INNER JOIN `teacher_course` ON (`teacher_enroll`.`course_id` = `teacher_course`.`id`) WHERE `teacher_course`.`name` LIKE BINARY %python%

 

跨表查询小节：需要查询的结果表名放在前面，然后把要查询的内容放在括号内。

原文地址https://www.cnblogs.com/hua888/p/10458486.html

你可能感兴趣的:(数据库,爬虫,python)

  • 理解Gunicorn：Python WSGI服务器的基石 范范0825 ipythonlinux运维
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
  • Python数据分析与可视化实战指南 William数据分析 pythonpython数据
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
  • python os.environ 江湖偌大 python深度学习
    os.environ['TF_CPP_MIN_LOG_LEVEL']='0'#默认值，输出所有信息os.environ['TF_CPP_MIN_LOG_LEVEL']='1'#屏蔽通知信息（INFO）os.environ['TF_CPP_MIN_LOG_LEVEL']='2'#屏蔽通知信息和警告信息（INFO\WARNING）os.environ['TF_CPP_MIN_LOG_LEVEL']='
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Python教程：一文了解使用Python处理XPath 旦莫 Python进阶python开发语言
    目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
  • Google earth studio 简介 陟彼高冈yu 旅游
    GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
  • python os.environ_python os.environ 读取和设置环境变量 weixin_39605414 pythonos.environ
    >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
  • 关于提高复杂业务逻辑代码可读性的思考 编程经验分享 开发经验java数据库开发语言
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
  • SQL Server_查询某一数据库中的所有表的内容 qq_42772833 SQLServer数据库sqlserver
    1.查看所有表的表名要列出CrabFarmDB数据库中的所有表（名），可以使用以下SQL语句：USECrabFarmDB;--切换到目标数据库GOSELECTTABLE_NAMEFROMINFORMATION_SCHEMA.TABLESWHERETABLE_TYPE='BASETABLE';对这段SQL脚本的解释：SELECTTABLE_NAME：这个语句的作用是从查询结果中选择TABLE_NAM
  • 使用Faiss进行高效相似度搜索 llzwxh888 faisspython
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
  • python是什么意思中文-在python中%是什么意思 编程大乐趣
    Python中%有两种：1、数值运算：%代表取模，返回除法的余数。如：>>>7%212、%操作符（字符串格式化，stringformatting），说明如下：%[(name)][flags][width].[precision]typecode(name)为命名flags可以有+，-，''或0。+表示右对齐。-表示左对齐。''为一个空格，表示在正数的左侧填充一个空格，从而与负数对齐。0表示使用0填
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具 nseejrukjhad 数据库python
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
  • Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Pythonpython开发语言大数据数据分析数据挖掘
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
  • python八股文面试题分享及解析(1) Shawn________ python
    #1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • Python快速入门 —— 第三节：类与对象 孤华暗香 Python快速入门python开发语言
    第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
  • MongoDB Oplog 窗口 喝醉酒的小白 MongoDB运维
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
  • pyecharts——绘制柱形图折线图 2224070247 信息可视化pythonjava数据可视化
    一、pyecharts概述自2013年6月百度EFE(ExcellentFrontEnd）数据可视化团队研发的ECharts1.0发布到GitHub网站以来，ECharts一直备受业界权威的关注并获得广泛好评，成为目前成熟且流行的数据可视化图表工具，被应用到诸多数据可视化的开发领域。Python作为数据分析领域最受欢迎的语言，也加入ECharts的使用行列，并研发出方便Python开发者使用的数据
  • Python 实现图片裁剪（附代码） | Python工具 剑客阿良_ALiang
    前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • python os 环境变量 CV矿工 python开发语言numpy
    环境变量：环境变量是程序和操作系统之间的通信方式。有些字符不宜明文写进代码里，比如数据库密码，个人账户密码，如果写进自己本机的环境变量里，程序用的时候通过os.environ.get（）取出来就行了。os.environ是一个环境变量的字典。环境变量的相关操作importos"""设置/修改环境变量：os.environ[‘环境变量名称’]=‘环境变量值’#其中key和value均为string类
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 【PG】常见数据库、表属性设置 江无羡 数据库
    PG的常见属性配置方法数据库复制、备份相关表的复制标识单表操作批量表操作链接数据库复制、备份相关表的复制标识单表操作通过ALTER语句单独更改一张表的复制标识。ALTERTABLE[tablename]REPLICAIDENTITYFULL;批量表操作通过代码块的方式，对某个schema中的所有表一起更新其复制标识。SELECTtablename,CASErelreplidentWHEN'd'TH
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（1） 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选1.数据预处理流程数据预处理的主要步骤工具和库2.介绍线性回归、逻辑回归模型线性回归（LinearRegression）模型形式：关键点：逻辑回归（LogisticRegression）模型形式：关键点：参数估计与评估：3.python浅拷贝及深拷贝浅拷贝（Shal
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • 《Python数据分析实战终极指南》 xjt921122 python数据分析开发语言
    对于分析师来说，大家在学习Python数据分析的路上，多多少少都遇到过很多大坑**，有关于技能和思维的**：Excel已经没办法处理现有的数据量了，应该学Python吗？找了一大堆Python和Pandas的资料来学习，为什么自己动手就懵了？跟着比赛类公开数据分析案例练了很久，为什么当自己面对数据需求还是只会数据处理而没有分析思路？学了对比、细分、聚类分析，也会用PEST、波特五力这类分析法，为啥
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • Python中深拷贝与浅拷贝的区别 yuxiaoyu.
    转自：http://blog.csdn.net/u014745194/article/details/70271868定义：在Python中对象的赋值其实就是对象的引用。当创建一个对象，把它赋值给另一个变量的时候，python并没有拷贝这个对象，只是拷贝了这个对象的引用而已。浅拷贝：拷贝了最外围的对象本身，内部的元素都只是拷贝了一个引用而已。也就是，把对象复制一遍，但是该对象中引用的其他对象我不复
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Java开发中，spring mvc 的线程怎么调用？ 小麦麦子 springmvc
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 问题：     在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
  • maven依赖范围 bitcarter maven
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 2.compile 只有编译和打包时才会依赖 3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 4.runtime 运行时依赖，编译不依赖 5.默认compile 依赖范围compile是支持传递的，test不支持传递 1.传递的意思是项目A，引用
  • Jaxb org.xml.sax.saxparseexception : premature end of file darrenzhu xmlprematureJAXB
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： org.xml.sax.saxparseexception : premature end of file 很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
  • CSS Specificity 周凡杨 html权重Specificitycss
      有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。     规则：   HTML标签的权重是1 Class 的权重是10 Id 的权重是100
  • java与servlet g21121 servlet
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 下面是java官方网站上对servlet的介绍： java官网对于servlet的解释 写道 Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
  • eclipse中安装maven插件 510888780 eclipsemaven
    1.首先去官网下载 Maven： http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 下载完成之后将其解压， 我将解压后的文件夹：apache-maven-3.2.3， 并将它放在 D:\tools目录下， 即 maven 最终的路径是：D:\tools\apache-mave
  • jpa@OneToOne关联关系 布衣凌宇 jpa
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 Nruser实体类 //***************************************************************** @Entity @Table(name="nruser") @DynamicInsert @Dynam
  • 我的spring学习笔记11-Spring中关于声明式事务的配置 aijuans spring事务配置
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
  • java 动态代理简单实现 antlove javahandlerproxydynamicservice
    dynamicproxy.service.HelloService package dynamicproxy.service; public interface HelloService { public void sayHello(); }   dynamicproxy.service.impl.HelloServiceImpl package dynamicp
  • JDBC连接数据库 百合不是茶 JDBC编程JAVA操作oracle数据库
             如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中;   JDBC链接数据库的代码和固定写法;     1,加载oracle数据库的驱动;     &nb
  • 单例模式中的多线程分析 bijian1013 javathread多线程java多线程
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 饿汉式： package com.bijian.study; public class Singleton { private Singleton() { } // 注意这是private 只供内部调用 private static
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性 bijian1013 JavaScriptprototype
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource bit1129 dataSource
    MyBatis内置了数据源的支持，如：   <environments default="development"> <environment id="development"> <transactionManager type="JDBC" /> <data
  • 我程序中用到的urldecode和base64decode,MD5 bitcarter cMD5base64decodeurldecode
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： string Base64Decode(const char* Data,int DataByte,int& OutByte) { //解码表 const char DecodeTable[] = { 0, 0, 0, 0, 0, 0
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密 ronin47
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素 bylijinnan java
    public class MinOfShiftedArray { /** * Q69 旋转数组的最小元素 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。 */ publ
  • 看博客，应该是有方向的 Cb123456 反省看博客
    看博客，应该是有方向的:  我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客.  我刚突然想到的:  1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。  2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的.    为什么要写
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖 comsci 开源项目
         为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。       所以，为避免这种不确定性风险，我
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ） cwqcwqmax9 sql
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 Web翻页优化实例 提交时间: 2004-6-18 15:37:49      回复    发消息  环境： Linux ve
  • Hibernat and Ibatis dashuaifu Hibernateibatis
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
  • 备份MYSQL脚本 dcj3sjt126com mysql
    #!/bin/sh # this shell to backup mysql #[email protected] (QQ:1413161683 DuChengJiu) _dbDir=/var/lib/mysql/ _today=`date +%w` _bakDir=/usr/backup/$_today [ ! -d $_bakDir ] && mkdir -p
  • iOS第三方开源库的吐槽和备忘 dcj3sjt126com ios
    转自 ibireme的博客   做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。   目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。   首先整理了一份 Github上排名靠
  • html wlwmanifest.xml eoems htmlxml
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 步骤： 加入到function.php remove_action('wp_head', 'wp_generator'); //wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog remov
  • 浅谈Java定时器发展 hacksin java并发timer定时器
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 Timer与ScheduleThreadPoolExecutor对比： 1.    Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
  • 移动端页面侧边导航滑入效果 ini jqueryWebhtml5cssjavascirpt
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： <!DOCTYPE html> <h
  • AspectJ+Javasist记录日志 kane_xie aspectjjavasist
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。   @Override public String get(String key) { // long start = System.currentTimeMillis(); // System.out.println("Be
  • redis学习笔记 MJC410621 redisNoSQL
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 1，处理超大量的数据 2，运行在便宜的PC服务器集群上， 3，击碎了性能瓶颈。 1)对数据高并发读写。 2)对海量数据的高效率存储和访问。 3)对数据的高扩展性和高可用性。 redis支持的类型： Sring 类型 set name lijie get name lijie set na
  • 使用redis实现分布式锁 qifeifei
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下：   public Long setnx(final byte[] key, final byte[] value) { checkIsInMulti(); client.setnx(key, value); ret
  • BI并非万能，中层业务管理报表要另辟蹊径 张老师的菜 大数据BI商业智能信息化
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。        BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题 wudixiaotie function
    1.在~/.bashrc最后加入 [[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm"  2.重新启动terminal输入：   rvm use ruby-2.2.1 --default  把当前安装的ruby版本设为默
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他