Django Model基础操作

关于设计django model

django为我们集成了ORM对数据库进行操作，我们只需要进行定义model，django就会自动为我们创建表，以及表之间的关联关系

创建好一个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作为你的数据库

 DATABASES = {

     'default': {

     'ENGINE': 'django.db.backends.mysql',

     'NAME':'库名称',

     'USER': '用户名',

     'PASSWORD': '密码',

     'HOST': '主机地址',

     'PORT': '端口',

     }

 }

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

注意

在python3.x中连接mysql

   - MySqlDB   (python2.x)

   - pymysql   (python3.x)

在settings配置目录的init.py中：

    import pymysql

    pymysql.install_as_MySQLdb()

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

类   --> 数据库的表

字段 --> 列

对象 --> 一行数据

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生成数据库表

	--执行下面的命令在数据库中生成对应的表

	python manage.py makemigrations

    python manage.py migrate

3.数据库基本操作

当我们在view视图函数中需要处理数据的时候,

	注意：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]