Django基础06-day21

################
# 2017-09-17 - 课上笔记
################


day21课上笔记 .. 2017-09-17


课前回顾：
	- Form组件验证
		参考：http://www.cnblogs.com/wupeiqi/articles/6144178.html
		- 先写好类：
			class LoginForm(Form):
				user = fields.CharField(...)
				emial = fields.EmailField(...)
				...
		- 使用之添加用户
			- 先实例化一个对象：form = LoginForm()
				前端：{{ form.user }} -> <input type=‘text‘ name=‘user‘ />
			- 等待用户输入，提交
			-添加，POST
				form = LoginForm(data=request.POST)
				form.is_valid()
				form.cleaned_data
				form.errors


		"""这里需要再练习下！！！"""
		- 修改用户：先发一个GET请求，/edit_user/user_id
			obj = models.UserInfo.objects.get(id=user_id)
			form = LoginForm(initial={‘user‘:obj.user})

			{{form.user}} -> <input type=‘text‘ name=‘user‘ value=‘数据库中的用户名‘ />

			等待用户输入内容，提交

		- 修改用户：再发一个POST请求，/edit_user/user_id
			form = LoginForm(data=request.POST)
			form.is_valid()
			form.cleaned_data:
				models.UserInfo.objects.filter(id=user_id).update(**cleaned_data)


		- 下拉框无法自动刷新的问题：
			‘‘‘
				dp_id = fields.ChoiceField(
			        required=True,
			        choices = [],
			    )
			    def __init__(self, *args, **kwargs):
			        # 找到类中的所有静态字段，然后拷贝并且赋值给 self.fields
			        super(UserInfoForm,self).__init__(*args, **kwargs)
			        self.fields[‘dp_id‘].choices = models.Depart.objects.values_list(‘id‘, ‘title‘)
			‘‘‘



	- FBV & CBV(用到了反射)
	- 序列化
		- Django内置的 serializers
		- json.dumps(xxx,cls=JsonCustomEncoder)
			- JsonCustomEncoder 在这个函数里自定义一些规则






day21今日内容
	- Form组件进行验证之进阶
	‘‘‘
		import re
		from django.forms import Form
		from django.forms import fields
		from django.forms import widgets
		from app01 import models
		from django.core.validators import RegexValidator
		from django.core.exceptions import ValidationError
	‘‘‘
		- 自定义验证规则方式一：使用RegexValidator对象
			‘‘‘
				自定义验证规则方式一：通过RegexValidator对象
			    phone = fields.CharField(
			        required=True,
			        validators=[RegexValidator(r‘^[0-9]+$‘, ‘请输入数字‘), RegexValidator(r‘^159[0-9]+$‘, ‘数字必须以159开头‘)],
			    )
			‘‘‘
		- 自定义验证规则方式二：自定义验证函数
			‘‘‘
				# 自定义验证规则函数，优点是可以有数据库操作
				def phone_validate(value):
				    mobile_re = re.compile(r‘^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$‘)
				    if not mobile_re.match(value):
				        raise ValidationError(‘手机号码格式错误‘)
				    if models.UserInfo.objects.filter(phone=value).count():
			            raise ValidationError(‘手机号码已经存在‘)

			    phone = fields.CharField(validators=[phone_validate,]) 
			‘‘‘
		- 自定义验证规则方式三：在当前类中使用钩子函数，函数名称必须符合 "clean_字段名称"
			‘‘‘
				phone = fields.CharField()
			    # 钩子方法
			    def clean_phone(self,):
			        """
			        只能取当前字段的值，切勿取其他的值
			        必须得有返回值
			        :return: 
			        """
			        # 需要要验证的值，自己写正则进行验证
			        # 去取用户提交的值
			        value = self.cleaned_data[‘phone‘]
			        mobile_re = re.compile(r‘^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$‘)
			        if not mobile_re.match(value):
			            raise ValidationError(‘手机号码格式错误‘)
			        if models.UserInfo.objects.filter(phone=value).count():
			            raise ValidationError(‘手机号码已经存在‘)
			        return value
			‘‘‘


		- 是否可以共存？   可以
		- 顺序是怎样的？
		# 看源码		

		1. form.is_valid()
		2. self.errors
		3. self.full_clean()
			- self._clean_fields()  # 即对 self.fields 进行循环验证，依次验证每一个字段：
				先执行自己字段的正则，再执行钩子函数
				先执行自己字段的正则，再执行钩子函数
				...

		    - self._clean_form()    # 字段都验证完后，再对整个form进行验证：
		    	- self.clean()
		    	- self.add_error(self, field, error)  # 如果有错误则把错误加到add_error里

		‘‘‘
			class RegisterForm(Form):
			    name = fields.CharField(
			        widget=widgets.TextInput(attrs={‘class‘: ‘c1‘})
			    )
			    email = fields.EmailField(
			        widget=widgets.EmailInput(attrs={‘class‘:‘c1‘})
			    )
			    phone = fields.CharField(
			        widget=widgets.Textarea(attrs={‘class‘:‘c1‘})
			    )
			    pwd = fields.CharField(
			        widget=widgets.PasswordInput(attrs={‘class‘:‘c1‘})
			    )
			    pwd_confirm = fields.CharField(
			        widget=widgets.PasswordInput(attrs={‘class‘: ‘c1‘})
			    )
			    
			    # 写在RegisterForm类里作用于 RegisterForm
			    # 以用户注册为例：用户输入密码，再次输入密码，这时候需要对两次密码进行比对
			    def clean(self):
			        pwd = self.cleaned_data[‘pwd‘]
			        pwd_confirm = self.cleaned_data[‘pwd_confirm‘]
			        if pwd == pwd_confirm:
			            return self.cleaned_data
			        else:
			            from django.core.exceptions import ValidationError
			            self.add_error(‘pwd‘, ValidationError(‘密码输入不一致‘))
			            self.add_error(‘pwd_confirm‘, ValidationError(‘密码输入不一致‘))
			            return self.cleaned_data
		‘‘‘



		    - self._post_clean()  	# 等同于 self._clean_form() ，可忽略


		‘‘‘
		# 源代码如下：
			def is_valid(self):
		        """
		        Returns True if the form has no errors. Otherwise, False. If errors are
		        being ignored, returns False.
		        """
		        return self.is_bound and not self.errors

			@property
		    def errors(self):
		        "Returns an ErrorDict for the data provided for the form"
		        if self._errors is None:
		            self.full_clean()
		        return self._errors

	        def full_clean(self):
		        """
		        Cleans all of self.data and populates self._errors and
		        self.cleaned_data.
		        """
		        self._errors = ErrorDict()
		        if not self.is_bound:  # Stop further processing.
		            return
		        self.cleaned_data = {}
		        # If the form is permitted to be empty, and none of the form data has
		        # changed from the initial data, short circuit any validation.
		        if self.empty_permitted and not self.has_changed():
		            return

		        self._clean_fields()
		        self._clean_form()
		        self._post_clean()

			def _clean_fields(self):
		        for name, field in self.fields.items():
		            # value_from_datadict() gets the data from the data dictionaries.
		            # Each widget type knows how to retrieve its own data, because some
		            # widgets split data over several HTML fields.
		            if field.disabled:
		                value = self.get_initial_for_field(field, name)
		            else:
		                value = field.widget.value_from_datadict(self.data, self.files, self.add_prefix(name))
		            try:
		                if isinstance(field, FileField):
		                    initial = self.get_initial_for_field(field, name)
		                    value = field.clean(value, initial)
		                else:
		                    value = field.clean(value)
		                self.cleaned_data[name] = value
		                if hasattr(self, ‘clean_%s‘ % name):
		                    value = getattr(self, ‘clean_%s‘ % name)()
		                    self.cleaned_data[name] = value
		            except ValidationError as e:
		                self.add_error(name, e)

		    def _clean_form(self):
		        try:
		            cleaned_data = self.clean()
		        except ValidationError as e:
		            self.add_error(None, e)
		        else:
		            if cleaned_data is not None:
		                self.cleaned_data = cleaned_data

		    def clean(self):
		        """
		        Hook for doing any extra form-wide cleaning after Field.clean() has been
		        called on every field. Any ValidationError raised by this method will
		        not be associated with a particular field; it will have a special-case
		        association with the field named ‘__all__‘.
		        """
		        return self.cleaned_data
		‘‘‘

		# 添加新用户demo
		‘‘‘
		# models.py
			class Depart(models.Model):
			    """部门表"""
			    title = models.CharField(max_length=32) # 数据库里就是string类型

			    class Meta:
			        verbose_name_plural = "部门表"

			class UserInfo(models.Model):
			    """用户表"""
			    name = models.CharField(max_length=32)
			    email = models.CharField(max_length=32)
			    phone = models.CharField(max_length=32)
			    pwd = models.CharField(max_length=64)
			    dp = models.ForeignKey(to=‘Depart‘,to_field=‘id‘)


		# forms.py
			import re
			from django.forms import Form
			from django.forms import fields
			from django.forms import widgets
			from app01 import models
			from django.core.validators import RegexValidator
			from django.core.exceptions import ValidationError

			class UserInfoForm(Form):
			    name = fields.CharField(
			        required=True,
			        min_length=2,
			        max_length=12,
			        error_messages={‘required‘: ‘用户名不能为空‘},
			        widget=widgets.TextInput(attrs={‘class‘: ‘form-control‘})
			    )   # 用户提交数据是字符串
			    pwd = fields.CharField(
			        required=True,
			        min_length=2,
			        max_length=12,
			        error_messages={‘required‘: ‘密码不能为空‘},
			        widget=widgets.PasswordInput(attrs={‘class‘: ‘form-control‘})
			    )
			    pwd_confirm = fields.CharField(
			        required=True,
			        min_length=2,
			        max_length=12,
			        error_messages={‘required‘: ‘确认密码不能为空‘},
			        widget=widgets.PasswordInput(attrs={‘class‘: ‘form-control‘})
			    )
			    email = fields.EmailField(
			        required=True,
			        error_messages={‘required‘: ‘邮箱不能为空‘, ‘invalid‘: ‘邮箱格式错误‘},
			        widget=widgets.TextInput(attrs={‘class‘: ‘form-control‘})
			    )
			    

			    # 自定义验证规则方式三：在当前类的方法中：clean_字段名称
			    dp_id = fields.ChoiceField(
			        choices=[],
			        error_messages={‘required‘: ‘请选择归属部门‘},
			        widget=widgets.Select(attrs={‘class‘: ‘form-control‘})
			    )
			    phone = fields.CharField(error_messages={‘required‘: ‘手机号不能为空‘})
			    # 钩子方法
			    def clean_phone(self,):
			        """
			        只能取当前字段的值，切勿取其他的值
			        必须得有返回值
			        :return: 
			        """
			        # 需要要验证的值，自己写正则进行验证
			        # 去取用户提交的值
			        value = self.cleaned_data[‘phone‘]
			        mobile_re = re.compile(r‘^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$‘)
			        if not mobile_re.match(value):
			            raise ValidationError(‘手机号码格式错误‘)
			        if models.UserInfo.objects.filter(phone=value).count():
			            raise ValidationError(‘手机号码已经存在‘)
			        return value

			    def __init__(self, *args, **kwargs):
			        # 找到类中的所有静态字段，然后拷贝并且赋值给 self.fields
			        super(UserInfoForm,self).__init__(*args, **kwargs)
			        # self.fields[‘dp_id‘].chioces = models.Depart.objects.all()
			        self.fields[‘dp_id‘].choices = models.Depart.objects.values_list(‘id‘, ‘title‘)

			    def clean(self):
			        print(self.cleaned_data,‘=====================‘)
			        pwd = self.cleaned_data.get(‘pwd‘)
			        pwd_confirm = self.cleaned_data.get(‘pwd_confirm‘)
			        if pwd == pwd_confirm:
			            return self.cleaned_data
			        else:
			            from django.core.exceptions import ValidationError
			            # self.add_error(‘pwd‘, ValidationError(‘密码输入不一致‘))
			            self.add_error(‘pwd_confirm‘, ValidationError(‘密码输入不一致‘))
			            return self.cleaned_data

		# add_user.html
			<form method="POST" novalidate>
		        {% csrf_token %}
		        <p> 用户名：{{ form.name }} {{ form.errors.name.0 }} </p>
		        <p> 密码：{{ form.pwd }} {{ form.errors.pwd.0 }} </p>
		        <p> 确认密码：{{ form.pwd_confirm }} {{ form.errors.pwd_confirm.0 }} </p>
		        <p> 邮箱：{{ form.email }} {{ form.errors.email.0 }}</p>
		        <p> 手机：{{ form.phone }} {{ form.errors.phone.0 }}</p>
		        <p> 部门：{{ form.dp_id }} {{ form.errors.dp_id.0 }}</p>
		        <input type="submit" value="提交" />
		    </form>

		# views.py
			def add_user(request):
			    if ‘GET‘ == request.method:
			        form = UserInfoForm()
			        return render(request, ‘add_user.html‘, {‘form‘: form})
			    else:
			        form = UserInfoForm(data=request.POST)
			        if form.is_valid():
			            form.cleaned_data.pop(‘pwd_confirm‘)
			            models.UserInfo.objects.create(**form.cleaned_data)
			            return redirect(‘/userinfo/‘)
			        return render(request, ‘add_user.html‘, {‘form‘: form})
		‘‘‘




		- 常用插件
			参考：http://www.cnblogs.com/wupeiqi/articles/6144178.html

			from django.forms import widgets

			# 单选：select
		    # city = fields.ChoiceField(
		    #     choices=[(0,"上海"),(1,‘北京‘)],
		    #     widget=widgets.Select(attrs={‘class‘: ‘c1‘})
		    # )
		    # 多选：select
		    # city = fields.MultipleChoiceField(
		    #     choices=[(1,"上海"),(2,‘北京‘)],
		    #     widget=widgets.SelectMultiple(attrs={‘class‘: ‘c1‘})
		    # )

		    # 单选：checkbox
		    # city = fields.CharField(
		    #     widget=widgets.CheckboxInput()
		    # )

		    # 多选：checkbox
		    # city = fields.MultipleChoiceField(
		    #     choices=((1, ‘上海‘), (2, ‘北京‘),),
		    #     widget=widgets.CheckboxSelectMultiple
		    # )

		    # 单选：radio
		    # city = fields.CharField(
		    #     initial=2,
		    #     widget=widgets.RadioSelect(choices=((1,‘上海‘),(2,‘北京‘),))
		    # )

		- 初始化的时候赋值，包括单值和多值

		注意：写默认值时，多选的值对应一个列表



	- 中间件
		- 中间件的执行时机：请求到来和请求返回时执行
		- 中间件就是一个类，里面有2个方法(也可以没有)：
			process_request(self,request)
				默认不写return，这本质上是 return None
			process_reponse(self,request,response)
				必须要写 return response

			另外还有：
			# 依次处理完所有request之后就进行路由匹配，然后再跳转到开头依次进行process_view函数处理
			process_view(self, request, callback, callback_args, callback_kwargs)

			# 捕获异常，自定义返回页面
			process_exception(self,request,exception)


		# Django中间件处理流程
		"""
			1. 循环中间件MIDDLEWARE列表里的中间件，依次执行每个中间件类的process_request(self,request)
			2. 进行路由匹配，拿到对应的视图函数
			3. 再次循环中间件MIDDLEWARE列表里的中间件，再从头依次执行每个中间件类的process_view(self, request, callback, callback_args, callback_kwargs)
			4. 执行对应的视图函数
			5. 逆序循环MIDDLEWARE列表里的中间件，依次执行每个中间件类的process_exception(self,request,exception)
			6. 再次逆序循环MIDDLEWARE列表里的中间件，依次执行每个中间件类的process_template_response(...)
			7. 再次逆序循环MIDDLEWARE列表里的中间件，依次执行每个中间件类的process_reponse(self,request,response)
		"""


		- 应用：
			- 记录访问日志
			- 判断用户是否登录

		# 中间件要继承 MiddlewareMixin类
		‘‘‘
		class MiddlewareMixin(object):
		    def __init__(self, get_response=None):
		        self.get_response = get_response
		        super(MiddlewareMixin, self).__init__()

		    def __call__(self, request):
		        response = None
		        if hasattr(self, ‘process_request‘):
		            response = self.process_request(request)
		        if not response:
		            response = self.get_response(request)
		        if hasattr(self, ‘process_response‘):
		            response = self.process_response(request, response)
		        return response
		‘‘‘



		‘‘‘
		HttpRequest.META

		一个标准的Python 字典，包含所有的HTTP 头部。具体的头部信息取决于客户端和服务器，下面是一些示例：

		CONTENT_LENGTH 			—— 请求的正文的长度（是一个字符串）。
		CONTENT_TYPE 			—— 请求的正文的MIME 类型。
		HTTP_ACCEPT 			—— 响应可接收的Content-Type。
		HTTP_ACCEPT_ENCODING	—— 响应可接收的编码。
		HTTP_ACCEPT_LANGUAGE 	—— 响应可接收的语言。
		HTTP_HOST 				—— 客服端发送的HTTP Host 头部。
		HTTP_REFERER 			—— Referring 页面。
		HTTP_USER_AGENT 		—— 客户端的user-agent 字符串。
		QUERY_STRING 			—— 单个字符串形式的查询字符串（未解析过的形式）。
		REMOTE_ADDR 			—— 客户端的IP 地址。
		REMOTE_HOST 			—— 客户端的主机名。
		REMOTE_USER 			—— 服务器认证后的用户。
		REQUEST_METHOD			—— 一个字符串，例如"GET" 或"POST"。
		SERVER_NAME 			—— 服务器的主机名。
		SERVER_PORT 			—— 服务器的端口（是一个字符串）。
		‘‘‘

		# 中间件示例1
		‘‘‘
		# settings.py
		MIDDLEWARE = [
			...
		    ‘middle.middleware.my_middleware1‘,
		    ‘middle.middleware.my_middleware2‘,
		]



		# ..\middle\middleware.py
		from django.shortcuts import render,HttpResponse,redirect
		from django.utils.deprecation import MiddlewareMixin

		class my_middleware1(MiddlewareMixin):
		    def process_request(self,request):
		        print(‘my_middleware1.process_request...‘)
		        print(request.path)
		        print(request.path_info)
		        print(request.method)
		        print(request.META[‘REMOTE_ADDR‘])
		        print(request.META[‘REMOTE_HOST‘])
		        print(request.META[‘REQUEST_METHOD‘])
		        print(request.META[‘HTTP_USER_AGENT‘])
		        print(request.META[‘HTTP_HOST‘])

		    def process_response(self,request,response):
		        print(‘my_middleware1.process_response...‘)
		        return response


		class my_middleware2(MiddlewareMixin):
		    def process_request(self,request):
		        print(‘my_middleware2.process_request...‘)

		    def process_response(self,request,response):
		        print(‘my_middleware2.process_response...‘)
		        return response
		‘‘‘
		
		# 中间件示例2 : 代替登录验证装饰器
		‘‘‘
		class my_middleware2(MiddlewareMixin):
		    def process_request(self,request):
		        if ‘/login/‘ == request.path_info:
		            return None
		        user_info = request.session.get(‘user_info‘)
		        if not user_info:
		            return redirect(‘/login/‘)

		    def process_response(self,request,response):
		        print(‘my_middleware2.process_response...‘)
		        return response
		‘‘‘




	- Django的缓存
	参考：http://www.cnblogs.com/wupeiqi/articles/5246483.html
		- 配置（默认不支持redis）
			- 开发调试，相当于没有
			- 本机内存中
			‘‘‘
				# 此缓存将内容保存至内存的变量中
			    # 配置：
			        CACHES = {
			            ‘default‘: {
			                ‘BACKEND‘: ‘django.core.cache.backends.locmem.LocMemCache‘,
			                ‘LOCATION‘: ‘unique-snowflake‘,
			            }
			        }
			‘‘‘
			- 本地文件中
			- 数据库中
			- Memcached
		- 使用
			- 全局 
				MIDDLEWARE = [
			        ‘django.middleware.cache.UpdateCacheMiddleware‘,
			        # 其他中间件...
			        ‘django.middleware.cache.FetchFromCacheMiddleware‘,
			    ]

			    CACHE_MIDDLEWARE_SECONDS = 10 # 设置缓存时间

			- 视图函数
				 from django.views.decorators.cache import cache_page

        		@cache_page(60 * 15)
        		def xxx(request):
        			pass

			- 局部模板
				a. 引入TemplateTag
			        {% load cache %}

			    b. 使用缓存
			        {% cache 5000 缓存key %}
			            缓存内容
			        {% endcache %}






	- 信号
		参考：http://www.cnblogs.com/wupeiqi/articles/5246483.html
		Django中提供了“信号调度”，用于在框架执行操作时解耦。
		通俗来讲，就是一些动作发生的时候，信号允许特定的发送者去提醒一些接受者。

		需求：在对数据库做增加操作时，记录操作日志


		推荐把信号的注册写到 项目目录下的 __init__()函数里

	‘‘‘
	# Django内置信号

	Model signals
	    pre_init                    # django的modal执行其构造方法前，自动触发
	    post_init                   # django的modal执行其构造方法后，自动触发
	    pre_save                    # django的modal对象保存前，自动触发
	    post_save                   # django的modal对象保存后，自动触发
	    pre_delete                  # django的modal对象删除前，自动触发
	    post_delete                 # django的modal对象删除后，自动触发
	    m2m_changed                 # django的modal中使用m2m字段操作第三张表（add,remove,clear）前后，自动触发
	    class_prepared              # 程序启动时，检测已注册的app中modal类，对于每一个类，自动触发
	Management signals
	    pre_migrate                 # 执行migrate命令前，自动触发
	    post_migrate                # 执行migrate命令后，自动触发
	Request/response signals
	    request_started             # 请求到来前，自动触发
	    request_finished            # 请求结束后，自动触发
	    got_request_exception       # 请求异常后，自动触发
	Test signals
	    setting_changed             # 使用test测试修改配置文件时，自动触发
	    template_rendered           # 使用test测试渲染模板时，自动触发
	Database Wrappers
	    connection_created          # 创建数据库连接时，自动触发
	‘‘‘

	‘‘‘
	信号模块引入位置：
	在项目文件加下的 __init__.py 文件里引入，并注册相关操作


	信号模块引入方式：

	from django.core.signals import request_finished
	from django.core.signals import request_started
	from django.core.signals import got_request_exception

	from django.db.models.signals import class_prepared
	from django.db.models.signals import pre_init, post_init
	from django.db.models.signals import pre_save, post_save
	from django.db.models.signals import pre_delete, post_delete
	from django.db.models.signals import m2m_changed
	from django.db.models.signals import pre_migrate, post_migrate

	from django.test.signals import setting_changed
	from django.test.signals import template_rendered

	from django.db.backends.signals import connection_created

	‘‘‘


	# 信号示例：旨在对数据库执行插入数据之前和之后触发各自的操作
	‘‘‘
		from django.db.models.signals import pre_save, post_save

		def pre_save_callback(sender, **kwargs):
		    print(">>>>>>>>>>> pre_save")
		    print(sender)
		    print(kwargs)

		def post_save_callback(sender, **kwargs):
		    print("################# post_save")
		    print(sender)
		    print(kwargs)

		pre_save.connect(pre_save_callback)
		post_save.connect(post_save_callback)
	‘‘‘

	# 执行结果：
	‘‘‘
	[18/Sep/2017 22:20:32] "POST /add_user/ HTTP/1.1" 200 1268
	>>>>>>>>>>> pre_save
	<class ‘app01.models.UserInfo‘>
	{‘signal‘: <django.db.models.signals.ModelSignal object at 0x0000000002CE79E8>, ‘instance‘: <UserInfo: UserInfo object>, ‘using‘: ‘default‘, ‘raw‘: False, ‘update_fields‘: None}
	################# post_save
	<class ‘app01.models.UserInfo‘>
	{‘signal‘: <django.db.models.signals.ModelSignal object at 0x0000000002CE7A90>, ‘instance‘: <UserInfo: UserInfo object>, ‘update_fields‘: None, ‘using‘: ‘default‘, ‘created‘: True, ‘raw‘: False}
	[18/Sep/2017 22:20:49] "POST /add_user/ HTTP/1.1" 302 0
	‘‘‘



	- Admin
		Django内置的Admin是对于model中对应的数据表进行增删改查提供的组件

		# 创建超级用户
		‘‘‘
			D:\soft\work\Python_17\day21\form_demo>python manage.py createsuperuser
			Username (leave blank to use ‘liulixin‘): root
			Email address:
			Password:
			Password (again):
			This password is too short. It must contain at least 8 characters.
			Password:
			Password (again):
			>>>>>>>>>>> pre_save
			<class ‘django.contrib.auth.models.User‘>
			{‘signal‘: <django.db.models.signals.ModelSignal object at 0x0000000002CEA7F0>, ‘using‘: ‘default‘, ‘instance‘: <User: root>, ‘
			raw‘: False, ‘update_fields‘: None}
			################# post_save
			<class ‘django.contrib.auth.models.User‘>
			{‘signal‘: <django.db.models.signals.ModelSignal object at 0x0000000002CEA898>, ‘created‘: True, ‘update_fields‘: None, ‘instan
			ce‘: <User: root>, ‘using‘: ‘default‘, ‘raw‘: False}
			Superuser created successfully.

			D:\soft\work\Python_17\day21\form_demo>
		‘‘‘

		更多admin做好的接口参考：http://www.cnblogs.com/wupeiqi/articles/7444717.html
		Django提供的对数据库的操作，admin.py 和 models.py 配合
		‘‘‘
			class Depart(models.Model):
			    """部门表"""
			    title = models.CharField(max_length=32) # 数据库里就是string类型

			    def __str__(self):
			        return self.title

			    class Meta:
			        verbose_name_plural = "部门表"

			class UserInfo(models.Model):
			    """用户表"""
			    name = models.CharField(max_length=32)
			    # email = models.EmailField(max_length=32)
			    email = models.CharField(max_length=32)
			    phone = models.CharField(max_length=32)
			    pwd = models.CharField(max_length=64)
			    dp = models.ForeignKey(to=‘Depart‘,to_field=‘id‘)

			    def __str__(self):
			        return self.name

			    class Meta:
			        verbose_name_plural = "用户表"
		‘‘‘


		在admin.py中只需要将Mode中的某个类注册，即可在Admin中实现增删改查的功能，如：
		‘‘‘
		# admin.py
			from django.contrib import admin
			from app01 import models

			# Register your models here.

			admin.site.register(models.UserInfo)
			admin.site.register(models.Depart)
		‘‘‘

		但是，这种方式比较简单，如果想要进行更多的定制操作，需要利用ModelAdmin进行操作，如：
		‘‘‘
		# admin.py
			from django.contrib import admin
			from app01 import models

			# Register your models here.

			class DepartAdmin(admin.ModelAdmin):
			    list_display = [‘id‘,‘title‘]
			    search_fields = [‘title‘, ]
			admin.site.register(models.Depart,DepartAdmin)


			class UserInfoAdmin(admin.ModelAdmin):
			    list_display = [‘id‘,‘name‘,‘email‘,‘phone‘,‘dp‘]
			    search_fields = [‘name‘, ]
			admin.site.register(models.UserInfo,UserInfoAdmin)
		‘‘‘


	- ModelForm

	- BBS项目练习
		- 前端知识捡一下
		- 各个小功能的设计和实现






用户表
	用户名
	密码

新闻表
	标题
	简介
	点赞个数	点赞时要更新字段，Django的F实现自增1
	评论个数
	新闻类型
	发布者
	新闻图表

新闻类型表
	类型名

点赞记录表

评论记录表