Django Model基础操做

时间 2019-12-11

原文原文链接

关于设计django model

django为咱们集成了ORM对数据库进行操做，咱们只须要进行定义model，django就会自动为咱们建立表，以及表之间的关联关系html

建立好一个django项目-首先在setting.py中配置你要使用的数据前端

1.再settings.py中添加你的app

#django自带的是sqlite3
#下面是自带的django 数据库设置
DATABASES = {
'default': {
    'ENGINE': 'django.db.backends.sqlite3',
    'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}

若是要想要使用mysql做为你的数据库python

DATABASES = {
     'default': {
     'ENGINE': 'django.db.backends.mysql',
     'NAME':'库名称',
     'USER': '用户名',
     'PASSWORD': '密码',
     'HOST': '主机地址',
     'PORT': '端口',
     }
 }

django关于数据库部分:https://docs.djangoproject.com/en/1.10/ref/settings/#databasesmysql

注意

在python3.x中链接mysql 
   - MySqlDB   (python2.x)
   - pymysql   (python3.x)
在settings配置目录的init.py中：
    import pymysql
    pymysql.install_as_MySQLdb()

1.定义表结构---建立一个类sql

类   --> 数据库的表
字段 --> 列
对象 --> 一行数据
from django.db import models
class UserInfo(models.Model):
    #设置自增加主键-若是不设置默认django会生成id列 为主键
    nid = models.AutoField(primary_key=True)
    #定义为字符，最大长度为32
    username = models.CharField(max_length=32)
    pwd = models.CharField(max_length=64)
    #定义为数字类型,
    age = models.IntegerField()

经常使用的model中的类型数据库

models.CharField        #字符类型
models.TextField        #文本框类型
models.IntegerField     #整型
models.BooleanField     #布尔型
models.AutoField        #自动增加
models.DateTimeField    #时间
models.DateField        #日期
models.EmailField       #邮箱
models.IPAddressField   #IP地址
models.ImageField       #图片
models.FileField        #文件
models.FilePathField    #文件路径
models.URLField         #URL类型

2.当咱们设计完表结构之后，根据app的models.py生成数据库表django

--执行下面的命令在数据库中生成对应的表
    
    python manage.py makemigrations
    python manage.py migrate

3.数据库基本操做python3.x

当咱们在view视图函数中须要处理数据的时候,app

注意：model里定义的大写-在调用的时候都是小写
    a. 查
        models.userinfo.objects.all()     #获取表中全部的数据tb(表)
        models.userinfo.objects.filter(nid=1)
        models.userinfo.objects.filter(nid=1).first() #若是不存在会返回None
        models.userinfo.objects.values()        #返回一个字典格式的
        models.userinfo.objects.value_list()    #返回一个列表格式
    
    b. 增
        models.userinfo.objects.create(...)   #添加数据的方式一
        
        obj = models.userinfo(...)            #添加数据方式二
        obj.save()
    c. 删
        models.userinfo.objects.all().delete()    #删除全部的数据
        models.userinfo.objects.filter(nid=1).delete()    #删除nid=1的数据
    d. 改
        models.userinfo.objects.all().update(...) #更新全部的数据
        models.userinfo.objects.filter(nid=1).update(...) #更新nid=1的数据

django_model高级部分

咱们先作一个准备工做函数

# 1.建立表
#定义一个部分表
class DePart(models.Model):
    title = models.CharField(max_length=16)
#用户表
class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=64)
    #用户是属于某一个部分的-是一对多的关系(一个部门对应多个用户)
    dp = models.ForeignKey(to="DePart",to_field="id",null=True,on_delete=models.SET_NULL)
    #用户是能够属于多个用户组-是多对多的关系(一个用户可对应多个组，一个组里也能够有多个用户) 这个manytomany 也能够放到用户组中   -自动建立表(userinfo_gp)
    gp = models.ManyToManyField('group')
#用户组表
class Group(models.Model):
    groupname = models.CharField(max_length=32)

咱们来讲一下表之间的关联关系

- 一对多关系(ForeignKey)
    经过对to='表名' to_field='要关联表的字段'设置进行一对多的关系
- 多对多关系(ManyToManyField)
    一种是用django自带的ManytoManyField，会自动建立一张userinfo_gp表(id,foreinkey,foreinkey)-维护对应关系
    一张是本身建立一个表进行维护，好处是列的数量能够本身定义
- 一对一关系(OneToOneField)

#经过view.py文件，建立对应的数据
views:

def test(request):
  models.DePart.objects.create(title='IT')
  models.DePart.objects.create(title='咨询')
  models.DePart.objects.create(title='公关')
 
  models.UserInfo.objects.create(username='alex',password='123',dp_id=1)
  models.UserInfo.objects.create(username='eric',password='123',dp_id=1)

下面进入咱们关键的查询部分

外键查询---ForeignKey-----

（正向）跨表操做：由包含ForeignKey的表查询另外一张表的内容，获取外键关联表的内容

格式：

obj.表名.列名

obj.表名_列名

# 1.获取对象 跨表查询1 
  # 经过all获取到的是一个列表形式[obj,obj,obj]
  # q=models.UserInfo.objects.all()
  # for row in q:
  #     print(row.username,row.password,row.dp_id,row.dp.id,row.dp.title,row.dp)

  # 2. 字典 跨表查询2
  # 经过values获取到的是一个字典形式
  # q=models.UserInfo.objects.values('username','password','dp_id','dp__title')
  # for row in q:
  #     print(row.username,row.password,row.dp_id,row.dp.id,row.dp.title,row.dp)

  # 3.元组 跨表查询3
  # 经过value_list获取到一个列表-元组的格式[(),(),()]
  # q=models.UserInfo.objects.values_list('username','password','dp_id','dp__title')
  # for row in q:
  #     print(row)
  #     print(row[0],row[3])

（反向）跨表 ,自己表内没有外键存在...但对方表中使用了该表作外键

格式

obj.表名_set.列名
obj.表名__列名
obj.表名_set.all()

若是正向的表中设置了related_name=‘xxx’

obj.xxx_set.列名

#两种操做类型，userinfo_set   和 userinfo__
  #1.对象
  # v=models.DePart.objects.all()
  # for row in v:
  #     print(row.id,row.title,row.userinfo_set.all())
  #2.字典
  # v=models.DePart.objects.values('id','title','userinfo__password','userinfo__password')
  # for row in v:
  #     print(row)
  #3.元组
  # v=models.DePart.objects.values_list('id','title','userinfo__username','userinfo__password')
  # for row in v:
  #     print(row)

2.多对多查询 ---ManyToManyField---

若是是本身建立的表，就直接对本身建立的第三张表进行操做。

经过ORM根据ManyToManyField字段生成的表进行操做

userinfo_obj=models.UserInfo.objects.filter(id=1).first()   #查找用户ID为1的数据
  # 1.添加数据的方式
  # userinfo_obj.m.add(1)              #添加用户ID为1，组ID为1 的
  # userinfo_obj.m.add(2,3,4)           #添加用户ID为1，组ID为2，3，4 的
  # userinfo_obj.m.add(*[1,2])

  # 2.删除数据的方式
  # userinfo_obj.m.remove(1)
  # userinfo_obj.m.remove(2,3)
  # userinfo_obj.m.remove(*[1,])

  # 3.清除数据
  # userinfo_obj.m.clear()       #清楚用户ID为1 的全部组数据

  #至关于更新操做,将全部的数据清除，再添加1，2
  # userinfo_obj.gp.set([1,2,])
  # q=userinfo_obj.gp.all()   #获取用户组的信息
  # print(q)

  #创建在上一次查询基础上，再次作二次筛选
  q = userinfo_obj.gp.filter(id__gt=1)
  print(q)
  return HttpResponse('123')
  前端展现：

关于ManyToMany字段：

操做：
      表设计
      class Ip(models.Model):
          '''全部IP地址'''
          ip = models.GenericIPAddressField(null=True)
          item = models.ForeignKey('Item')
          platform = models.ForeignKey('Platform',null=False)
          m_port = models.ManyToManyField('Port')
      class Port(models.Model):
          port = models.IntegerField()
          comment = models.CharField(max_length=64,null=True,blank=True)
          def __str__(self):
              return str(self.port)
      views：

          all_ip = models.Ip.objects.all()
          # for i in all_ip:
          #     print(i.m_port.all())
          return render(request, 'ip_list.html',locals())
      前端展现：
           {% for ip_obj in all_ip %}
          <td>{% for port in ip_obj.m_port.all %}{{ port.port }},{% endfor %}</td>
          {% endfor %}

后续增长ORM操做内容

ORM 建立表

FK经常使用操做

class A(Model):
      name = models.CharField(....)

  class B(Model):
      name = models.Charfild(...)
      fk = models.FK(A)

B表中有几列
```
id
  name
  fk_id
```

a.跨表操做

b_list = models.B.objects.all()
  for item in b_list:
      item.id
      item.name
      item.fk_id
      item.fk
      item.fk.name
      item.k.id

b.跨表操做

b_list = models.B.objects.values("id","name","fk_id","fk__name")
  for item in b_list:
      item["id"]
      item["name"]
      item["fk_id"]
      item["fk__name"]

c.跨表操做

b_list = models.B.objects.value_list("id","name","fk_id","fk__name")
  for item in b_list:
      item[0]
      item[1]
      item[2]
      item[3]

d.跨表操做

models.B.objects.filter(fk__name="李鹏飞")

M2M 经常使用操做

class A(Model):
      name = models.CharField(....)

  class B(Model):
      name = models.Charfild(...)
      m = models.M2M(A)

a. B表中有几列
id
name

PS: 自动生成一个第三张表：m 用于间接的对第三张表进行操做

b. 在B表中插入三条数据: A表中插入2条数据
models.A.objects.create(name="张")
models.A.objects.create(name="三")
models.A.objects.create(name="丰")
```
models.B.objects.create(name="兴普")
  models.B.objects.create(name="香香")
  models.B.objects.create(name="皮皮")
```

c. 兴普和【张，三，丰】建立关系

obj = models.B.objects.create(name="兴普")
  obj.m.add(1)
  obj.m.add(2)
  obj.m.add(*[1,2,3])

d. 查找和兴普有关系的人？

obj = models.B.objects.create(name="兴普")
  obj.m.all() [A-obj,A-obj]

1. Django之Model操做 Django之Model操做
2. Django基础-Model数据库操做
3. Django - Model操做
4. Django-------Model操做
5. Django —— model基础
6. django model基础
7. Django之Model操做
8. Django之model操做
9. Django 基础操做
10. Python学习-django-Model操做 Django之Model操做
更多相关文章...
• Kotlin 基础语法 - Kotlin 教程
• Scala 基础语法 - Scala教程
• Kotlin学习（二）基本类型
• ☆基于Java Instrument的Agent实现