Django模型

MTV开发模式

把数据存取逻辑、业务逻辑和表现逻辑组合在一起的概念有时被称为软件架构的Model-View-Controller(MVC)模式。在这个模式中，Model代表数据存取层，View代表的是系统中选择显示什么和怎么显示的部分，Controller指的是系统中根据用户输入并视需要访问模型，以决定使用哪个视图的那部分。

Django紧紧地遵循这种MVC模式，可以称得上是一种MVC框架。

以下是Django中M、V和C各自的含义：

1. M： 数据存取部分，由django数据库层处理;
2. V： 选择显示哪些数据要显示以及怎样显示的部分，由视图和模板处理;
3. C： 根据用户输入委派视图的部分，由Django框架根据URLconf设置，对给定URL调用适当的Python函数;

C由框架自行处理，而Django里更关注的是模型(Model)、模板(Template)和视图(Views)，Django也被称为MTV框架，在MTV开发模式中：

1. M 代表模型(Model)，即数据存取层，该层处理与数据相关的所有事务：如何存取、如何验证有效性、包含哪些行为以及数据之间的关系等;
2. T 代表模板(Template)，即表现层，该层处理与表现相关的决定：如何在页面或其他类型文档中进行显示;
3. V 代表视图(View)，即业务逻辑层，该层包含存取模型及调取恰当模板的相关逻辑，你可以把它看作模型与模板之间的桥梁;

数据库配置

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.mysql',
        'NAME': 'yang',
        'USER': 'root',
        'PASSWORD': '111111',
        'HOST': '127.0.0.1',
        'PORT': '3306'
    }
}

以下是一个MySQL数据库的配置属性：

字段	描述
ENGINE	使用的数据库引擎
NAME	数据库名称
USER	那个用户连接数据库
PASSWORD	用户的密码
HOST	数据库服务器
PORT	端口

ENGINE字段所支持的内置数据库

• django.db.backends.postgresql
• django.db.backends.mysql
• django.db.backends.sqlite3
• django.db.backends.oracle

无论你选择使用那个数据库都必须安装此数据库的驱动，即python操作数据库的介质，在这里你需要注意的是python3.x并不支持使用MySQLdb模块，但是你可以通过pymysql来替代mysqldb，首先你需要安装pymysql模块：

pip3 install pymysql

然后在项目的__init__.py文件加入以下两行配置：

import pymysql
pymysql.install_as_MySQLdb()

当数据库配置完成之后，我们可以使用python manage.py shell进入项目测试，输入下面这些指令来测试你的数据库配置：

➜  yangxxx git:(master) ✗ python3 manage.py shell
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 08:49:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from django.db import connection
>>> cursor = connection.cursor()

没有报错,则说明数据库配置正确.

实战

创建一个新的app

让我们来创建一个Django app，一个包含模型，视图和Django代码，并且形式为独立Python包的完整Django应用。

Project和app之间的不同就是一个是配置另一个是代码：

1. 一个Project包含很多个Django app以及对它们的配置;
2. 技术上，Project的作用是提供配置文件，比方说哪里定义数据库连接信息, 安装的app列表，TEMPLATE等等;
3. 一个app是一套Django功能的集合，通常包括模型和视图，按Python的包结构的方式存在;
4. 例如，Django本身内建有一些app，例如注释系统和自动管理界面，app的一个关键点是它们是很容易移植到其他Project和被多个Project复用。

如果你使用了Django的数据库层(模型)，你必须创建一个Django app，模型必须存放在apps中，因此，为了开始建造我们的模型，我们必须创建一个新的app：

➜  yangxxx git:(master) ✗ python3 manage.py startapp darker

➜  yangxxx git:(master) ✗ tree darker
darker
├── __init__.py
├── admin.py
├── apps.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.py

1 directory, 7 files

第一个模型

首先创建三张表

1. 学生表(student) , 拥有字段: id/sname/gender
2. 课程表(course) , 拥有字段: id/cname
3. 成绩表(score) , 拥有字段: id/student_id/course_id

打开app的models.py目录输入以下代码：

from django.db import models

# Create your models here.

class student(models.Model):
    # 自增主键,如果没有定义,Django会自动帮我们创建一个
    id = models.AutoField
    sname = models.CharField(max_length=12)
    gender = models.CharField(max_length=2)

class course(models.Model):
    # 自增主键,如果没有定义,Django会自动帮我们创建一个
    id = models.AutoField
    cname = models.CharField(max_length=12)

class score(models.Model):
    # 自增主键,如果没有定义,Django会自动帮我们创建一个
    id = models.AutoField
    # 设置外键关联
    student_id = models.ForeignKey(student)
    course_id = models.ForeignKey(course)

每个数据模型都是django.db.models.Model的子类,它的父类Model包含了所有必要的和数据库交互的方法，并提供了一个简洁漂亮的定义数据库字段的语法,每个模型相当于单个数据库表，每个属性也是这个表中的一个字段,属性名就是字段名.

模型安装

要通过django在数据库中创建这些表，首先我们需要在项目中激活这些模型，将darker app添加到配置文件的已安装应用列表中即可完成此步骤;

编辑settings.py文件,找到INSTALLED_APPS设置,INSTALLED_APPS告诉Django项目哪些app处于激活状态：

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'darker',
]

通过下面的指令来创建数据表

# 检查是否正确
➜  yangxxx git:(master) ✗ python3 manage.py check
System check identified no issues (0 silenced).

# 在数据库中生成表
➜  yangxxx git:(master) ✗ python3 manage.py makemigrations
Migrations for 'darker':
  darker/migrations/0001_initial.py
    - Create model course
    - Create model score
    - Create model student
    - Add field student_id to score

# 生成数据
➜  yangxxx git:(master) ✗ python3 manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, darker, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying admin.0002_logentry_remove_auto_add... OK
  Applying contenttypes.0002_remove_content_type_name... OK
  Applying auth.0002_alter_permission_name_max_length... OK
  Applying auth.0003_alter_user_email_max_length... OK
  Applying auth.0004_alter_user_username_opts... OK
  Applying auth.0005_alter_user_last_login_null... OK
  Applying auth.0006_require_contenttypes_0002... OK
  Applying auth.0007_alter_validators_add_error_messages... OK
  Applying auth.0008_alter_user_username_max_length... OK
  Applying darker.0001_initial... OK
  Applying sessions.0001_initial... OK

django1.7之前的版本都是：

python manage.py syncdb

django1.7及之后的版本做了修改，把1步拆成了2步，变成

python manage.py makemigrations
python manage.py migrate

查看创建的数据表

mysql> use yang;
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A

Database changed
mysql> show tables;
+----------------------------+
| Tables_in_yang             |
+----------------------------+
| auth_group                 |
| auth_group_permissions     |
| auth_permission            |
| auth_user                  |
| auth_user_groups           |
| auth_user_user_permissions |
| darker_course              |
| darker_score               |
| darker_student             |
| django_admin_log           |
| django_content_type        |
| django_migrations          |
| django_session             |
+----------------------------+
13 rows in set (0.01 sec)

基本数据访问

运行 python3 manager.py shell 并使用Django提供的高级Python API

➜  yangxxx git:(master) ✗ python3 manage.py shell
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 08:49:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)

# 导入student模型类,通过这个类我们可以与student数据表进行交互
>>> from darker.models import student

# 创建一个student类的实例并设置字段sname,gender
>>> s1 = student(sname='yang',gender='m')
# 调用该对象的save()方法,将对象保存到数据库中,Django会在后台执行一条INSERT语句
>>> s1.save()
>>> s2 = student(sname='s2',gender='w')
>>> s2.save()

# 使用student.objects属性从数据库取出student表的记录集,这个属性又许多方法,student.objects.all()方法获取数据库中student类的所有对象,实际上Django执行了一条SQL SELECT语句
>>> student_list = student.objects.all()
>>> student_list
<QuerySet [<student: student object>, <student: student object>, <student: student object>]>

让获取到的数据显示为字符串格式

只需要在上面三个表类中添加一个方法 __str__,如下:

from django.db import models

# Create your models here.

class student(models.Model):
    id = models.AutoField
    sname = models.CharField(max_length=12)
    gender = models.CharField(max_length=2)

    def __str__(self):
        return self.sname

class course(models.Model):
    id = models.AutoField
    cname = models.CharField(max_length=12)

    def __str__(self):
        return self.cname

class score(models.Model):
    id = models.AutoField
    student_id = models.ForeignKey(student)
    course_id = models.ForeignKey(course)

重新进入shell

➜  yangxxx git:(master) ✗ python3 manage.py shell
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 08:49:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from darker.models import student
>>> student_list = student.objects.all()
# 此次获取的是字符串而不是对象了
>>> student_list
<QuerySet [<student: yang>, <student: yang>, <student: s2>]>

插入和更新数据

# 插入数据
>>> s1 = student(sname='qaz',gender='m')
# 将数据保存到数据库
>>> s1.save()
# 获取刚插入的数据的ID
>>> s1.id
4
# 修改数据内容
>>> s1.gender='w'
>>> s1.save()
# 相当于执行了命令:
# UPDATE darker_student SET gender = 'w' WHERE id=4;

选择对象

下面的指令是从数据库中获取所有的数据

>>> student.objects.all()
<QuerySet [<student: yang>, <student: yang>, <student: s2>, <student: qaz>]>

Django在选择所有数据时并没有使用 SELECT *,而是显式列出了所有字段, SELECT * 会更慢,而且最重要的是列出所有字段遵循了Python的一个信条: 明言胜于暗示

数据过滤

使用filter()方法对数据过滤

>>> student.objects.filter(sname='qaz',gender='w')
<QuerySet [<student: qaz>]>

在sname和contains之间有双下划线,gender部分会被Django翻译成LIKE语句

>>> student.objects.filter(sname__contains='y')
<QuerySet [<student: yang>, <student: yang>]>

翻译成下面的SQL语句:

SELECT id,sname,gender FROM darker_student WHERE name LIKE '%y%'

获取单个对象

>>> student.objects.get(sname='qaz')
<student: qaz>

数据排序

使用order_by()这个方法进行排序

>>> student.objects.order_by("sname")
<QuerySet [<student: qaz>, <student: s2>, <student: yang>, <student: yang>]>
>>>

如果需要以多个字段为标准进行排序(第二个字段会在第一个字段的值相同的情况下被使用到),使用多个参数就可以了,如下:

>>> student.objects.order_by("sname","gender")
<QuerySet [<student: qaz>, <student: s2>, <student: yang>, <student: yang>]>

指定逆序排序

>>> student.objects.order_by('-sname')
<QuerySet [<student: yang>, <student: yang>, <student: s2>, <student: qaz>]>

设置数据的默认排序

如果你设置了这个选项,那么除非你检索时特意额外地使用了order_by(),否则,当你使用Django的数据库API去检索时,student对象的相关返回值默认地都会按sname字段排序.

class student(models.Model):
    id = models.AutoField
    sname = models.CharField(max_length=12)
    gender = models.CharField(max_length=2)

    def __str__(self):
        return self.sname
    class Meta:
        ordering = ['sname']

连锁查询

>>> from darker.models import student
>>> student.objects.filter(id='2').order_by('-sname')
<QuerySet [<student: yang>]>

限制返回的数据

>>> student.objects.order_by('sname')[0]
<student: qaz>
>>> student.objects.order_by('sname')[1]
<student: s2>

类似的,你可以用python的列表切片来获取数据

>>> student.objects.order_by('sname')[0:2]
<QuerySet [<student: qaz>, <student: s2>]>

虽然不支持负索引,但是我们可以使用其他的方法,比如稍微修改order_by()语句来实现

>>> student.objects.order_by('-sname')[0]
<student: yang>

更新多个对象

更改某一指定的列,我们可以调用结果集(QuerySet)对象的update()方法

>>> student.objects.filter(id=2).update(sname='Hello')
1

# update()方法对于任何结果集(QuerySet)均有效,这意味着你可以同时更新多条记录,比如将所有实例的性别都改为女
>>> student.objects.all().update(gender='w')
4

update()方法会返回一个整型数值,表示受影响的记录条数

删除对象

删除数据库中的对象只需要调用该对象的delete()方法

删除指定数据

>>> student.objects.all().filter(sname='yang').delete()
(1, {'darker.score': 0, 'darker.student': 1})
>>> student.objects.all()
<QuerySet [<student: Hello>, <student: qaz>, <student: s2>]>

删除所有数据

>>> student.objects.all().delete()
(3, {'darker.score': 0, 'darker.student': 3})
>>> student.objects.all()
<QuerySet []>

字段属性

属性所拥有的方法

连表结构

方法	描述
models.ForeignKey(其他表)	一对多
models.ManyToManyField(其他表)	多对多
models.OneToOneField(其他表)	一对一

报错信息

django.db.utils.InternalError: (1366, "Incorrect string value: '\\xE7\\x94\\xB7' for column 'gender' at row 1")

原因,| yang     | CREATE DATABASE `yang` /*!40100 DEFAULT CHARACTER SET latin1 */ |

实战3

连表操作一对一

在 app 的models.py文件内添加一下内容用户创建一对多关系表

class UserType(models.Model):
    nid = models.AutoField(primary_key=True)
    caption = models.CharField(max_length=32)

class UserInfo(models.Model):
    username = models.CharField(max_length=32)
    password = models.CharField(max_length=16)
    user_type = models.ForeignKey('UserType')

把app的名字添加到项目的settings.py配置文件的INSTALLED_APPS中,然后在数据库中生成表

➜  yangxxx git:(master) ✗ python3 manage.py makemigrations
Migrations for 'darker':
  darker/migrations/0002_auto_20170617_0902.py
    - Create model UserInfo
    - Create model UserType
    - Change Meta options on student
    - Add field user_type to userinfo
➜  yangxxx git:(master) ✗ python3 manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, darker, sessions
Running migrations:
  Applying darker.0002_auto_20170617_0902... OK

基本操作

➜  yangxxx git:(master) ✗ python3 manage.py shell
Python 3.5.3 (v3.5.3:1880cb95a742, Jan 16 2017, 08:49:46)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
(InteractiveConsole)
>>> from darker import models

# 通过create方式进行数据的添加
>>> models.UserType.objects.create(caption='superadmin')
<UserType: UserType object>
# 通过save保存的方式添加数据
>>> obj = models.UserType(caption='admin')
>>> obj.save()

# 通过字典的方式进行数据添加
>>> UserInfoDict = {'username': 'yang','password': 'helloword','user_type': models.UserType.objects.get(nid=1)}

# 通过**UserInfoDict把数据以字典的方式传给create
>>> models.UserInfo.objects.create(**UserInfoDict)
<UserInfo: UserInfo object>
>>> UserInfoDict = {'username': 'qwe','password': 'xxxxxxxx','user_type': models.UserType.objects.get(nid=2)}
>>> models.UserInfo.objects.create(**UserInfoDict)
<UserInfo: UserInfo object>

# 如果知道user_type_id代表多少,可以直接写数字
>>> UserInfoDict = {'username': 'yang','password': 'helloworld','user_type_id': 2}
>>> models.UserInfo.objects.create(**UserInfoDict)
<UserInfo: UserInfo object>

修改数据

# 指定条件更新
>>> models.UserInfo.objects.filter(password='helloword').update(password='hw')
1

# 获取id=1的这条数据对象
>>> obj = models.UserInfo.objects.get(id=1)
# 修改username字段
>>> obj.username = 'as'
# 保存操作
>>> obj.save()

删除数据

>>> models.UserInfo.objects.filter(username='as').delete()
(1, {'darker.UserInfo': 1})

查询数据

# 查询单条数据,不存在则报错
>>> models.UserInfo.objects.get(id=2)
<UserInfo: UserInfo object>
>>> models.UserInfo.objects.get(id=5)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/django/db/models/manager.py", line 85, in manager_method
    return getattr(self.get_queryset(), name)(*args, **kwargs)
  File "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/django/db/models/query.py", line 380, in get
    self.model._meta.object_name
darker.models.DoesNotExist: UserInfo matching query does not exist.

# 获取全部数据
>>> models.UserInfo.objects.all()
<QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>

# 获取指定条件的数据
>>> models.UserInfo.objects.filter(username='qwe')
<QuerySet [<UserInfo: UserInfo object>]>

单表查询

查询出来的结果都是QuerySet对象

query方法是用来查看查询语句的,及Django生成的SQL

>>> ret = models.UserType.objects.all()
>>> print(ret.query)
SELECT `darker_usertype`.`nid`, `darker_usertype`.`caption` FROM `darker_usertype`

values与values_list

>>> ret = models.UserType.objects.all().values('nid')
# 返回的列表,列表里面套字典
>>> print(type(ret),ret)
<class 'django.db.models.query.QuerySet'> <QuerySet [{'nid': 1}, {'nid': 2}]>

>>> ret = models.UserType.objects.all().values_list('nid')
# 返回一个列表,列表里面套集合
>>> print(type(ret),ret)
<class 'django.db.models.query.QuerySet'> <QuerySet [(1,), (2,)]>

双下划线连表操作

>>> ret = models.UserInfo.objects.all().values('username','user_type__caption')
>>> print(ret.query)
SELECT `darker_userinfo`.`username`, `darker_usertype`.`caption` FROM `darker_userinfo` INNER JOIN `darker_usertype` ON (`darker_userinfo`.`user_type_id` = `darker_usertype`.`nid`)

>>> ret = models.UserInfo.objects.all()
>>> for item in ret:
...   print(item,item.id,item.user_type.nid,item.user_type.caption,item.user_type_id)
...
UserInfo object 2 2 admin 2
UserInfo object 3 2 admin 2

查询实例

获取用户类型是超级管理员的所有用户

正向查找

通过双下划线连表查询

>>> ret = models.UserInfo.objects.filter(user_type__caption = 'admin').values('username','user_type__caption')
>>> print(ret,type(ret),ret.query)
<QuerySet [{'username': 'qwe', 'user_type__caption': 'admin'}, {'username': 'yang', 'user_type__caption': 'admin'}]> <class 'django.db.models.query.QuerySet'> SELECT `darker_userinfo`.`username`, `darker_usertype`.`caption` FROM `darker_userinfo` INNER JOIN `darker_usertype` ON (`darker_userinfo`.`user_type_id` = `darker_usertype`.`nid`) WHERE `darker_usertype`.`caption` = admin

反向查找

先查找UserType表中数据,再把这个数据和UserInfo表中进行过滤

>>> obj = models.UserType.objects.filter(caption= 'admin').first()
>>> print(obj.nid,obj.caption)
2 admin
>>> print(obj.userinfo_set.all())
<QuerySet [<UserInfo: UserInfo object>, <UserInfo: UserInfo object>]>

把UserType表里的所有字段和userinfo表进行一个匹配,如果有匹配到就显示出来

>>> ret = models.UserType.objects.all().values('nid','caption','userinfo__username')
>>> print(ret)
<QuerySet [{'userinfo__username': 'qwe', 'nid': 2, 'caption': 'admin'}, {'userinfo__username': 'yang', 'nid': 2, 'caption': 'admin'}, {'userinfo__username': None, 'nid': 1, 'caption': 'superadmin'}]>

连表操作多对多

两种创建多对多表的方式

手动指定第三张表进行创建

class HostGroup(models.Model):
    hgid = models.AutoField(primary_key=True)
    host_id = models.ForeignKey('Host')
    group_id = models.ForeignKey('Group')

class Host(models.Model):
    hid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32)
    ip = models.CharField(max_length=32)

class Group(models.Model):
    gid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)

    h2g = models.ManyToManyField('Host',through='HostGroup')

➜  yangxxx git:(master) ✗ python3 manage.py makemigrations
Migrations for 'darker':
  darker/migrations/0003_auto_20170619_0137.py
    - Create model Group
    - Create model Host
    - Create model HostGroup
    - Add field h2g to group
➜  yangxxx git:(master) ✗ python3 manage.py migrate
Operations to perform:
  Apply all migrations: admin, auth, contenttypes, darker, sessions
Running migrations:
  Applying darker.0003_auto_20170619_0137... OK

django帮我们创建第三张表

创建一下表关系用于测试多对多

class Host(models.Model):
    hid = models.AutoField(primary_key=True)
    hostname = models.CharField(max_length=32)
    ip = models.CharField(max_length=32)

class Group(models.Model):
    gid = models.AutoField(primary_key=True)
    name = models.CharField(max_length=16)
    # 任意一个字段，会自动生成第三张表，且第三张表会自动的添加联合唯一索引，Unique
    h2g = models.ManyToManyField('Host')

---

插入数据测试

# Host插入数据
>>> from darker import models
>>> models.Host.objects.create(hostname='localhost',ip='192.168.1.1')
<Host: Host object>
>>> models.Host.objects.create(hostname='linux-node1',ip='192.168.1.2')
<Host: Host object>
>>> models.Host.objects.create(hostname='linux-node2',ip='192.168.1.3')
<Host: Host object>
>>> models.Host.objects.create(hostname='web-node1',ip='192.168.1.4')
<Host: Host object>

# Group插入数据
>>> models.Group.objects.create(name='markte dep')
<Group: Group object>
>>> models.Group.objects.create(name='sales dep')
<Group: Group object>
>>> models.Group.objects.create(name='tec dep')
<Group: Group object>

单个添加数据

>>> obj = models.Group.objects.get(name='tec dep')
>>> obj.gid, obj.name
(4, 'tec dep')
# 获取第三张表的内容
>>> obj.h2g.all()
<QuerySet []>
>>> h1 = models.Host.objects.get(hid=2)
>>> h1.ip
'192.168.1.2'
>>> obj.h2g.add(h1)
Traceback (most recent call last):
  File "<console>", line 1, in <module>
  File "/Library/Frameworks/Python.framework/Versions/3.5/lib/python3.5/site-packages/django/db/models/fields/related_descriptors.py", line 929, in add
    (opts.app_label, opts.object_name)
AttributeError: Cannot use add() on a ManyToManyField which specifies an intermediary model. Use darker.HostGroup's Manager instead.

批量导入bulk_create()

User.objects.create()每保存一条就执行一次SQL

bulk_create()是执行一条SQL存入多条数据，做会快很多！能用列表解析代替 for 循环就使用列表解析

如果导入数据重复时,只需要使用 User.objects.get_or_create(title=title,content=content)

python_code/xxx/django_xxx/menjin/create_records.py

...
    user_card_dic = {}
    for tup in rows:
        if tup[2] in user_card_dic.keys():
            user_card_dic[tup[2]]["DoorName"] += "," + tup[0]
        else:
            tmp_dict = {}
            tmp_dict["DoorName"] = tup[0]
            tmp_dict["ConsumerName"] = tup[1]
            tmp_dict["CardNO"] = tup[2]
            tmp_dict["ConsumerID"] = tup[3]
            tmp_dict["GroopName"] = tup[4]
            user_card_dic[tup[2]] = tmp_dict
            #user_list.append(tmp_dict)
    #print(user_card_dic)
    user_object_list = []
    for user in user_card_dic.values():
        # user # {'ConsumerID': 700, 'ConsumerName': '张三', 'GroopName': '内部运营\\行政', 'DoorName': 'xxF-办公区', 'CardNO': 102999}
        print(user)
        user_object_list.append(User(**user))
    print(user_object_list)
    print(len(user_object_list))
    #print(user_list)

    # User.objects.bulk_create(user_object_list)