Flask Web开发从入门到放弃(一)

 

• 第1章 章节一

• 01 内容概要

• 02 内容回顾

• 03 路飞学城之加入购物车

• 04 路飞学城之结算

• 05 路飞学城之立即支付

• 06 路飞学城之后续计划

• 07 Flask框架简介和快速使用

• 08 FLask框架之用户管理系统示例（一）

• 09 Flask框架之用户管理系统示例（二）

• 第2章 章节二

• 01 内容概要

• 02 内容回顾

• 03 Flask框架之配置

• 04 Flask框架之创建路由的两种方式

• 05 Flask框架之反向生成URL

• 06 Flask框架之自定义路由转换器

• 07 Flask框架之app.route参数

• 08 Flask框架之获取子域名的路由

• 09 上述内容总结

• 10 Flask框架之视图中添加装饰器

• 11 Flask框架之CBV和FBV

• 12 Flask框架之请求和响应相关

• 13 Flask框架之模板引擎

• 14 Flask框架之session使用和源码流程（一）

• 15 Flask框架之session使用和源码流程（二）

• 16 Flask框架之before_request和after_request(一)

• 17 Flask框架之after_request(二)

• 18 Flask框架字号常见装饰器

• 19 上述内容总结

• 20 Flask之闪现

• 21 Flask中间件

• 22 Flask框架之蓝图（一）

• 23 Flask框架之蓝图（二）

• 24 拓展知识：pipreqs

• 25 拓展知识：函数和方法

• 第3章 章节三

• 01 内容概要

• 02 内容回顾

• 03 threading.local学习

• 04 自定义Local思路

• 05 自定义Local对象（基于函数）

• 06 自定义Local对象（基于面向对象）

• 07 Flask上下文管理之本质分析

• 08 Flask上下文管理之请求到处理阶段

• 09 Flask上下文管理之视图调用阶段

• 10 Flask上下文管理之视图调动阶段和结束阶段

• 11 问题来了

• 12 Flask中的g到底是什么呢？生命周期

• 13 内容补充：面向对象的私有字段

• 14 homework

• 第4章 章节四

• 01 内容概要

• 02 内容回顾

• 03 路飞学城补充：视频播放授权

• 04 flask-session组件使用和原理（一）

• 05 flask-session组件使用和原理（二）

• 06 flask-session组件使用和原理（三）

• 07 flask-session组件使用和原理（四）

• 08 基于pymysql实现用户登录

• 09 基于数据库连接池实现用户登录

• 10 解决bug（一）

• 11 解决bug（二）

• 12 数据库连接池总结

• 13 WTforms介绍以及用户登录示例

• 14 WTforms用户注册示例

• 15 内容总结

• 16 homework

第1章 章节一

01 内容概要

1.1 路飞购买流程

• 加入购物车
• 结算
• 去支付

1.2 Flask框架

• 路由
• 视图
• 模板
• session
• ...

02 内容回顾

2.1 路飞学城项目结构

　　2.1.1 前后端分离；

　　2.1.2 导师后台+管理后台+主站（本人负责）

2.2 主站的功能

　　2.2.1 Vue——兼职、课程列表、详细、深科技

　　2.2.2 rest api

• 课程系列——列表、详细、推荐课程、章节&课时、常见问题、评论
• 深科技——文章列表、详细、评论、赞、收藏
• 个人中心——我的账户、个人资料、订单、课程中心
• 购买流程（复杂）——加入购物车、去结算、立即支付
• 其他——关于我们、联系我们、意见反馈

2.3 技术点

　　2.3.1 rest framework框架——认证组件（用于用户认证） or Django中间件，两者实现的时机不同，认证逻辑无需实现；

　　2.3.2 跨域——jsonp（动态生成script标签） cors；

　　2.3.3 Redis——购物逻辑，用户session两个场景下使用；

• 频繁操作；
• 中间状态；
• 数据放入内容，速度快；
• Redis锁

　　2.3.4 支付宝支付接口

• RSA加密；
• 数字金额有要求，保留小数点后两位；
• 两个URL；
• 支付宝公钥和商户私钥；

　　2.3.5 微信消息推送

• 微信企业号
• 沙箱环境
• 普通消息和模板消息
• 关注公众号，生成二维码
• 通过js生成二维码
• 唯一标识获取到

　　2.3.6 ContenType

• 参考Django settings
• 参考Django 中间件

　　2.3.7 rest framework分页

　　2.3.8 接口写的最多的查询接口；

　　2.3.9 视图

• queryset

　　2.3.10 序列化

• __new__方法;
• source
• Method

　　2.3.11 Git协同开发

　　2.3.12 ORM操作

• only
• defer
• exclude
• filter

　　2.3.13 CRSF

• 基于中间件做
• 基于装饰器

　　2.3.14 Vue.js基本命令

• Vue.js的基本命令
• Router拦截器
• Ajax——jQuery、axios ——本质都是XMLHttpRequest对象实现；
• 请求头Content-Type：request.POST
• json
• vuex
• vue-cookies

　　2.3.15 面试题总结准备

　　2.3.16 组织架构、人员配比、项目周期；

03 路飞学城之加入购物车

3.1 加入购物车 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import json
from django.core.exceptions import ObjectDoesNotExist
from django.conf import settings

from rest_framework.views import APIView
from rest_framework.viewsets import ViewSetMixin
from rest_framework.viewsets import ModelViewSet
from rest_framework.response import Response

from repository import models

from api.serializer.payment import ShoppingCarSerializer
from api.utils.auth.token_auth import LuffyTokenAuthentication
from api.utils.auth.token_permission import LuffyPermission
from api.utils import redis_pool
from api.utils.exception import PricePolicyDoesNotExist


class ShoppingCarView(ViewSetMixin, APIView):
    """
    购物车接口
    """
    authentication_classes = [LuffyTokenAuthentication, ]
    permission_classes = [LuffyPermission, ]

    def get(self, request, *args, **kwargs):
        """
        根据用户ID获取购物车所有东西
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1000, 'data': None}
        try:
            product_dict = redis_pool.conn.hget(settings.REDIS_SHOPPING_CAR_KEY, request.user.id)
            if product_dict:
                product_dict = json.loads(product_dict.decode('utf-8'))
                response['data'] = product_dict
        except Exception as e:
            response['code'] = 1001
            response['msg'] = "获取购物车列表失败"

        return Response(response)

    def post(self, request, *args, **kwargs):
        """
        # 根据课程ID获取课程信息以及相关所有价格策略
        chopping_car = {
            request.user.id:{
                course.id:{
                        title:'xx',
                        img:'xx',
                        choice_policy_id:1,
                        price_policy_dict:{
                            {id:1,price:'9.9', period:'1个月'},
                            {id:2,price:'19.9',period:'3个月'},
                            {id:3,price:'59.9',period:'8个月'},
                        },
                    }
                }，
                course.id:[
                        title:'xx',
                        img:'xx',
                        choice_policy_id:1,
                        price_policy_dict:{
                            {id:1,price:'9.9', period:'1个月'},
                            {id:2,price:'19.9',period:'3个月'},
                            {id:3,price:'59.9',period:'8个月'},
                        },
                    ]
                }
            }
        }
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """

        response = {'code': 1000, 'msg': None}
        try:
            course_id = int(request.data.get('course_id'))
            policy_id = int(request.data.get('policy_id'))

            # 获取课程信息
            course = models.Course.objects.exclude(course_type=2).filter(status=0).get(id=course_id)

            # 序列化课程信息，并获取其关联的所有价格策略
            ser = ShoppingCarSerializer(instance=course, many=False)
            product = ser.data

            # 判断价格策略是否存在
            policy_exist = False
            for policy in product['price_policy_list']:
                if policy['id'] == policy_id:
                    policy_exist = True
                    break
            if not policy_exist:
                raise PricePolicyDoesNotExist()

            # 设置默认选中的价格策略
            product.setdefault('choice_policy_id', policy_id)
            # 获取当前用户在购物车中已存在的课程，如果存在则更新，否则添加新课程
            product_dict = redis_pool.conn.hget(settings.REDIS_SHOPPING_CAR_KEY, request.user.id)
            if not product_dict:
                product_dict = {course_id: product}
            else:
                product_dict = json.loads(product_dict.decode('utf-8'))
                product_dict[course_id] = product
            # 将新课程写入到购物车
            redis_pool.conn.hset(settings.REDIS_SHOPPING_CAR_KEY, request.user.id, json.dumps(product_dict))

        except ObjectDoesNotExist as e:
            response['code'] = 1001
            response['msg'] = '视频不存在'
        except PricePolicyDoesNotExist as e:
            response['code'] = 1002
            response['msg'] = '价格策略不存在'
        except Exception as e:
            print(e)
            response['code'] = 1003
            response['msg'] = '添加购物车失败'

        return Response(response)

    def delete(self, request, *args, **kwargs):
        """
        删除购物车中的课程
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1000}
        try:
            course_id = kwargs.get('pk')
            product_dict = redis_pool.conn.hget(settings.REDIS_SHOPPING_CAR_KEY, request.user.id)
            if not product_dict:
                raise Exception('购物车中无课程')
            product_dict = json.loads(product_dict.decode('utf-8'))
            if course_id not in product_dict:
                raise Exception('购物车中无该商品')
            del product_dict[course_id]
            redis_pool.conn.hset(settings.REDIS_SHOPPING_CAR_KEY, request.user.id, json.dumps(product_dict))
        except Exception as e:
            response['code'] = 1001
            response['msg'] = str(e)

        return Response(response)

    def put(self, request, *args, **kwargs):
        """
        更新购物车中的课程的默认的价格策略
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1000}
        try:
            course_id = kwargs.get('pk')
            policy_id = request.data.get('policy_id')
            product_dict = redis_pool.conn.hget(settings.REDIS_SHOPPING_CAR_KEY, request.user.id)
            if not product_dict:
                raise Exception('购物车清单不存在')
            product_dict = json.loads(product_dict.decode('utf-8'))
            if course_id not in product_dict:
                raise Exception('购物车清单中商品不存在')

            policy_exist = False
            for policy in product_dict[course_id]['price_policy_list']:
                if policy['id'] == policy_id:
                    policy_exist = True
                    break
            if not policy_exist:
                raise PricePolicyDoesNotExist()

            product_dict[course_id]['choice_policy_id'] = policy_id
            redis_pool.conn.hset(settings.REDIS_SHOPPING_CAR_KEY, request.user.id, json.dumps(product_dict))
        except PricePolicyDoesNotExist as e:
            response['code'] = 1001
            response['msg'] = '价格策略不存在'
        except Exception as e:
            response['code'] = 1002
            response['msg'] = str(e)

        return Response(response)

04 路飞学城之结算

4.1 结算 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import json
import datetime
from django.conf import settings

from rest_framework.views import APIView
from rest_framework.response import Response

from api.utils.auth.token_auth import LuffyTokenAuthentication
from api.utils.auth.token_permission import LuffyPermission
from api.utils import redis_pool
from repository import models


class PaymentView(APIView):
    """
    去结算接口
    """
    authentication_classes = [LuffyTokenAuthentication, ]
    permission_classes = [LuffyPermission, ]

    def get(self, request, *args, **kwargs):
        """
        获取结算列表
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1000}
        try:
            # 结算商品列表
            payment_list = redis_pool.conn.hget(settings.REDIS_PAYMENT_KEY, request.user.id)
            if not payment_list:
                raise Exception()

            response['data'] = {
                'payment_list': json.loads(payment_list.decode('utf-8')),  # 结算信息（课程、价格和优惠券）
                "balance": request.user.balance  # 个人贝里账户，可使用贝里金额
            }
        except Exception as e:
            response['code'] = 1001
            response['msg'] = "结算列表为空"

        return Response(response)

    def post(self, request, *args, **kwargs):
        """
        去结算
            方案一（示例）：用户提交课程id，去redis购物车中获取其选好的价格策略，再次检测课程和价格策略的合法性。
                   PS: 直接购买时，需要先加入购物车，再立即去结算

            方案二：用户提交课程id和价格策略id，去数据库验证其合法性。
                   PS: 直接购买时，直接去结算
            
            user.id: {
                policy_course_dict:{
                    课程ID:{
                        'course_id': course_id,
                        'course_name': product['name'],
                        'course_img': product['course_img'],
                        'policy_id': product['choice_policy_id'],
                        'policy_price': policy_price,
                        'policy_': policy_period,
                        'coupon_record_list': [
                            {'id': 0, 'text': '请选择优惠券'},
                            {'id': 1, 'type':1, 'text': '优惠券1', ..},
                            {'id': 2, 'type':2, 'text': '优惠券1', ..},
                            {'id': 3, 'type':3, 'text': '优惠券1', ..},
                        ],
                    },
                    课程ID:{
                        'course_id': course_id,
                        'course_name': product['name'],
                        'course_img': product['course_img'],
                        'policy_id': product['choice_policy_id'],
                        'policy_price': policy_price,
                        'policy_': policy_period,
                        'coupon_record_list': [
                            {'id': 0, 'text': '请选择优惠券'},
                            {'id': 1, 'type':1, 'text': '优惠券1', ..},
                            {'id': 2, 'type':2, 'text': '优惠券1', ..},
                            {'id': 3, 'type':3, 'text': '优惠券1', ..},
                        ],
                    }
                },
                global_coupon_dict:{
                    1:{'type': 0, 'text': "通用优惠券", 'id': 1, ..},
                    2:{'type': 0, 'text': "通用优惠券", 'id': 2, ..},
                    3:{'type': 0, 'text': "通用优惠券", 'id': 3, ...},
                    4:{'type': 0, 'text': "通用优惠券", 'id': 4, ...},
                }
            }  
                   
            
        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1001}
        try:

            """
            1. 获取要支付的课程ID
            2. 检查购物车中是否存在，不存在则报错
                循环用户提交的课程ID，去购物车中获取，如果不存在，就报错。
                
            """
            # 获取用户提交的课程id
            course_id_list = request.data.get('course_list')
            if not course_id_list or not isinstance(course_id_list, list):
                raise Exception('请选择要结算的课程')

            # 购物车中检查是否已经有课程（应该有课程的）
            product_dict = redis_pool.conn.hget(settings.REDIS_SHOPPING_CAR_KEY, request.user.id)
            if not product_dict:
                raise Exception('购物车无课程')

            # 购物车中是否有用户要购买的课程
            product_dict = json.loads(product_dict.decode('utf-8'))

            # ###### 课程、价格和优惠券 #######
            policy_course_dict = {}

            for course_id in course_id_list:
                course_id = str(course_id)
                product = product_dict.get(course_id)
                if not product:
                    raise Exception('购买的课程必须先加入购物车')

                policy_exist = False
                for policy in product['price_policy_list']:
                    if policy['id'] == product['choice_policy_id']:
                        policy_price = policy['price']
                        policy_period = policy['period']
                        policy_valid_period = policy['valid_period']
                        policy_exist = True
                        break
                if not policy_exist:
                    raise Exception('购物车中的课程无此价格')

                policy_course = {
                    'course_id': course_id,
                    'course_name': product['name'],
                    'course_img': product['course_img'],
                    'policy_id': product['choice_policy_id'],
                    'policy_price': policy_price,
                    'policy_period': policy_period,
                    'policy_valid_period': policy_valid_period,
                    'coupon_record_list': [
                        {'id': 0, 'text': '请选择优惠券'},
                    ],
                }
                policy_course_dict[course_id] = policy_course

            # 获取当前所有优惠券
            user_coupon_list = models.CouponRecord.objects.filter(account=request.user,
                                                                  status=0)
            # ###### 全局优惠券 #######
            global_coupon_record_dict = {}

            # 课程优惠券添加到课程中；全局优惠券添加到全局
            current_date = datetime.datetime.now().date()
            for record in user_coupon_list:
                # 检查优惠券是否已经过期
                begin_date = record.coupon.valid_begin_date
                end_date = record.coupon.valid_end_date
                if begin_date:
                    if current_date < begin_date:
                        continue
                if end_date:
                    if current_date > end_date:
                        continue
                # 全局优惠券
                if not record.coupon.content_type:
                    if record.coupon.coupon_type == 0:
                        temp = {'type': 0, 'text': "通用优惠券", 'id': record.id,
                                'begin_date': begin_date, 'end_date': end_date,
                                'money_equivalent_value': record.coupon.money_equivalent_value}
                    elif record.coupon.coupon_type == 1:
                        temp = {'type': 1, 'text': "满减券", 'id': record.id,
                                'begin_date': begin_date, 'end_date': end_date,
                                'minimum_consume': record.coupon.minimum_consume,
                                'money_equivalent_value': record.coupon.money_equivalent_value}
                    elif record.coupon.coupon_type == 2:
                        temp = {'type': 2, 'text': "折扣券", 'id': record.id,
                                'begin_date': begin_date, 'end_date': end_date,
                                'off_percent': record.coupon.off_percent}
                    else:
                        continue

                    global_coupon_record_dict[record.id] = temp
                # 课程优惠券
                else:
                    cid = record.coupon.object_id
                    if record.coupon.content_type.model == 'course' and cid in policy_course_dict:
                        # 课程价格：满减，打折，通用
                        if record.coupon.coupon_type == 0:
                            temp = {'type': 0, 'text': "通用优惠券", 'id': record.id,
                                    'begin_date': begin_date, 'end_date': end_date,
                                    'money_equivalent_value': record.coupon.money_equivalent_value}
                        elif record.coupon.coupon_type == 1 and policy_course_dict[cid][
                            'policy_price'] >= record.coupon.minimum_consume:
                            temp = {'type': 1, 'text': "满减券", 'id': record.id,
                                    'begin_date': begin_date, 'end_date': end_date,
                                    'minimum_consume': record.coupon.minimum_consume,
                                    'money_equivalent_value': record.coupon.money_equivalent_value}
                        elif record.coupon.coupon_type == 2:
                            temp = {'type': 2, 'text': "折扣券", 'id': record.id,
                                    'begin_date': begin_date, 'end_date': end_date,
                                    'off_percent': record.coupon.off_percent}
                        else:
                            continue
                        policy_course_dict[cid]['coupon_record_list'].append(temp)

            user_pay = {
                'policy_course_dict': policy_course_dict,
                'global_coupon_record_dict': global_coupon_record_dict
            }
            redis_pool.conn.hset(settings.REDIS_PAYMENT_KEY, request.user.id, json.dumps(user_pay))

        except Exception as e:
            response['code'] = 1002
            response['msg'] = str(e)

        return Response(response)

05 路飞学城之立即支付

5.1 立即支付 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
import json
import time
import random
import datetime
from django.conf import settings
from django.db import transaction
from django.db.models import F

from rest_framework.views import APIView
from rest_framework.response import Response

from api.utils.auth.token_auth import LuffyTokenAuthentication
from api.utils.auth.token_permission import LuffyPermission
from api.utils import redis_pool
from api.utils.alipay import AliPay

from repository import models


def generate_order_num():
    """
    生成订单编号, 且必须唯一
    :return:
    """
    while True:
        order_num = time.strftime('%Y%m%d%H%M%S', time.localtime()) + str(random.randint(111, 999))
        if not models.Order.objects.filter(order_number=order_num).exists():
            break
    return order_num


def generate_transaction_num():
    """
    生成流水编号, 且必须唯一
    :return:
    """
    while True:
        transaction_number = time.strftime('%Y%m%d%H%M%S', time.localtime()) + str(random.randint(111, 999))
        if not models.TransactionRecord.objects.filter(transaction_number=transaction_number).exists():
            break
    return transaction_number


class PayOrderView(APIView):
    authentication_classes = [LuffyTokenAuthentication, ]
    permission_classes = [LuffyPermission, ]

    def post(self, request, *args, **kwargs):
        """
        去支付，生成订单。
        获取前端提交的购买信息
            {
                course_price_list:[
                    {'policy_id':1, '':'course_id':1, 'coupon_record_id':1},
                    {'policy_id':2, '':'course_id':2, 'coupon_record_id':2},
                ],
                coupon_record_id:1,
                alipay: 99,
                balance: 1
            }

        1. 用户提交
            - balance
            - alipay
        2. 获取去结算列表

        课程
        3. 循环所有课程
            - 获取原价
            - 抵扣的钱




        :param request: 
        :param args: 
        :param kwargs: 
        :return: 
        """
        response = {'code': 1000}
        try:
            # 用户请求验证
            policy_course_list = request.data.get('course_price_list')
            coupon_record_id = request.data.get('coupon_record_id')
            alipay = request.data.get('alipay')  # >= 0
            balance = request.data.get('balance')  # >= 0

            if balance > request.user.balance:
                raise Exception('账户中贝里余额不足')

            # 检查用户提交的信息在 redis结算列表 中是否存在，如果不存在，则需要用户从购物车中再次去结算
            payment_dict_bytes = redis_pool.conn.hget(settings.REDIS_PAYMENT_KEY, request.user.id)
            payment_dict = json.loads(payment_dict_bytes.decode('utf-8'))

            policy_course_dict = payment_dict['policy_course_dict']
            global_coupon_record_dict = payment_dict['global_coupon_record_dict']

            global_coupon_record = {}
            # 全局优惠券
            if coupon_record_id:
                if  coupon_record_id not in global_coupon_record_dict:
                    raise Exception('全局优惠券在缓存中不存在')
                global_coupon_record = global_coupon_record_dict[coupon_record_id]

            # 当前时间
            current_date = datetime.datetime.now().date()
            current_datetime = datetime.datetime.now()

            # 原价
            total_price = 0
            # 总抵扣的钱
            discount = 0
            # 使用优惠券ID列表
            if coupon_record_id:
                use_coupon_record_id_list = [coupon_record_id, ]
            else:
                use_coupon_record_id_list=[]
            # 课程和优惠券
            buy_course_record = []

            for cp in policy_course_list:
                _policy_id = cp['policy_id']
                _course_id = cp['course_id']
                _coupon_record_id = cp['coupon_record_id']

                temp = {
                    'course_id': _course_id,
                    'course_name': "course",
                    'valid_period': 0,  # 有效期：30
                    'period': 0,  # 有效期：一个月
                    'original_price': 0,
                    'price': 0,
                }


                if str(_course_id) not in policy_course_dict:
                    raise Exception('课程在缓存中不存在')

                redis_course = policy_course_dict[str(_course_id)]

                if str(_policy_id) != str(redis_course['policy_id']):
                    raise Exception('价格策略在缓存中不存在')

                # 课程是否已经下线或价格策略被修改
                policy_object = models.PricePolicy.objects.get(id=_policy_id)  # 价格策略对象
                course_object = policy_object.content_object  # 课程对象

                if course_object.id != _course_id:
                    raise Exception('课程和价格策略对应失败')
                if course_object.status != 0:
                    raise Exception('课程已下线，无法购买')

                # 选择的优惠券是否在缓存中
                redis_coupon_list = redis_course['coupon_record_list']
                redis_coupon_record = None
                for item in redis_coupon_list:
                    if item['id'] == _coupon_record_id:
                        redis_coupon_record = item
                        break
                if not redis_coupon_record:
                    raise Exception('单课程优惠券在缓存中不存在')

                # 计算购买原总价
                total_price += policy_object.price

                # 未使用单课程优惠券
                if redis_coupon_record['id'] == 0:
                    temp['price'] = policy_object.price
                    buy_course_record.append(temp)
                    continue

                temp['original_price'] = policy_object.price
                temp['valid_period'] = redis_coupon_record['policy_valid_period']
                temp['period'] = redis_coupon_record['policy_period']

                # 缓存中的优惠券是否已经过期
                begin_date = redis_coupon_record.get('begin_date')
                end_date = redis_coupon_record.get('end_date')
                if begin_date:
                    if current_date < begin_date:
                        raise Exception('优惠券使用还未到时间')
                if end_date:
                    if current_date > end_date:
                        raise Exception('优惠券已过期')

                # 使用的是单课程优惠券抵扣了多少钱；使用的 个人优惠券ID
                if redis_coupon_record['type'] == 0:
                    # 通用优惠券
                    money = redis_coupon_record['money_equivalent_value']
                    discount += money
                elif redis_coupon_record['type'] == 1:
                    # 满减券
                    money = redis_coupon_record['money_equivalent_value']
                    minimum_consume = redis_coupon_record['minimum_consume']
                    if policy_object.price >= minimum_consume:
                        discount += money
                elif redis_coupon_record['type'] == 2:
                    # 打折券
                    money = policy_object.price * redis_coupon_record['off_percent']
                    discount += money

                temp['price'] = policy_object.price - money
                buy_course_record.append(temp)
                use_coupon_record_id_list.append(redis_coupon_record['id'])

            # 全局优惠券
            print(global_coupon_record)
            begin_date = global_coupon_record.get('begin_date')
            end_date = global_coupon_record.get('end_date')
            if begin_date:
                if current_date < begin_date:
                    raise Exception('优惠券使用还未到时间')
            if end_date:
                if current_date > end_date:
                    raise Exception('优惠券已过期')

            # 使用全局优惠券抵扣了多少钱
            if global_coupon_record.get('type') == 0:
                # 通用优惠券
                money = global_coupon_record['money_equivalent_value']
                discount += money
            elif global_coupon_record.get('type') == 1:
                # 满减券
                money = global_coupon_record['money_equivalent_value']
                minimum_consume = global_coupon_record['minimum_consume']
                if (total_price - discount) >= minimum_consume:
                    discount += money
            elif global_coupon_record.get('type') == 2:
                # 打折券
                money = (total_price - discount) * global_coupon_record['off_percent']
                discount += money

            # 贝里抵扣的钱
            if balance:
                discount += balance

            if (alipay + discount) != total_price:
                raise Exception('总价、优惠券抵扣、贝里抵扣和实际支付的金额不符')

            # 创建订单 + 支付宝支付
            # 创建订单详细
            # 贝里抵扣 + 贝里记录
            # 优惠券状态更新
            actual_amount = 0
            if alipay:
                payment_type = 1  # 支付宝
                actual_amount = alipay
            elif balance:
                payment_type = 3  # 贝里
            else:
                payment_type = 2  # 优惠码

            with transaction.atomic():
                order_num = generate_order_num()
                if payment_type == 1:
                    order_object = models.Order.objects.create(
                        payment_type=payment_type,
                        order_number=order_num,
                        account=request.user,
                        actual_amount=actual_amount,
                        status=1,  # 待支付
                    )
                else:
                    order_object = models.Order.objects.create(
                        payment_type=payment_type,
                        order_number=order_num,
                        account=request.user,
                        actual_amount=actual_amount,
                        status=0,  # 支付成功，优惠券和贝里已够支付
                        pay_time=current_datetime
                    )

                for item in buy_course_record:

                    detail = models.OrderDetail.objects.create(
                        order=order_object,
                        content_object=models.Course.objects.get(id=item['course_id']),
                        original_price=item['original_price'],
                        price=item['price'],
                        valid_period_display=item['period'],
                        valid_period=item['valid_period']
                    )
                models.Account.objects.filter(id=request.user.id).update(balance=F('balance') - balance)
                models.TransactionRecord.objects.create(
                    account=request.user,
                    amount=request.user.balance,
                    balance=request.user.balance - balance,
                    transaction_type=1,
                    content_object=order_object,
                    transaction_number=generate_transaction_num()
                )
                effect_row = models.CouponRecord.objects.filter(id__in=use_coupon_record_id_list).update(
                    order=order_object,
                    used_time=current_datetime)


                if effect_row != len(use_coupon_record_id_list):
                    raise Exception('优惠券使用失败')

                response['payment_type'] = payment_type
                # 生成支付宝URL地址
                if payment_type == 1:
                    pay = AliPay(debug=True)
                    query_params = pay.direct_pay(
                        subject="路飞学城",  # 商品简单描述
                        out_trade_no=order_num,  # 商户订单号
                        total_amount=actual_amount,  # 交易金额(单位: 元 保留俩位小数)
                    )
                    pay_url = "https://openapi.alipaydev.com/gateway.do?{}".format(query_params)

                    response['pay_url'] = pay_url

        except IndentationError as e:
            response['code'] = 1001
            response['msg'] = str(e)

        return Response(response)

06 路飞学城之后续计划

6.1 后续计划

07 Flask框架简介和快速使用

7.1 Flask Web框架；

7.1.1 Flask的上下文管理；

7.1.2 谈谈你对Python相关的Web框架的理解;

• Django：大而全，重武器，内部提供：ORM、Admin、中间件、Form、ModelForm、Session、缓存、信号、CSRF；
• Flask：短小精悍，可拓展强，http://flask.pocoo.org/ 
• Tornado,短小精悍，可拓展性较之Flask弱一些，但优点是：异步非阻塞；
• Web.py：比较老的Web框架；
• bottle.py：微小，1000行左右；
• Django的请求过来先走wsgiref，然后middleware；
• Flask中的WSGI是Werkzurg；

7.2 如何证明Flask内部是Werkzeug

　　7.2.1 Flask的路由是装饰器；

# -*- coding:utf-8 -*-
# Project: FlaskFull 
# Software: PyCharm
# Time    : 2018-09-17 10:12
# File    : s2.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Flask

app = Flask(__name__)


@app.route('/index/')
def index():
    return 'Hello World!'


if __name__ == '__main__':
    app.run()#run_simple(host,port,app)

08 FLask框架之用户管理系统示例（一）

8.1 Flask框架之用户登录程序；

8.2 使用Pycharm安装Flask；

from flask import Flask, render_template, request, redirect, session

app = Flask(__name__, template_folder='templates')
# 基于app这个对象设置secret_key的值，任意设置！
app.secret_key = 'nishifdalkj4389!@#$28908'


@app.route('/login/', methods=['GET', 'POST'])
def hello_world():
    # return 'Hello World!'
    if request.method == "GET":
        return render_template('login.html')
    user = request.form.get('usr')
    pwd = request.form.get('pwd')
    if user == 'cuixiaozhao' and pwd == '123456':
        # 将用户信息放入session;
        session['user_info'] = user
        """
        RuntimeError: The session is unavailable because no secret key was set.  Set the secret_key on the application to something unique and secret.
127.0.0.1 - - [17/Sep/2018 21:02:04] "POST /login/ HTTP/1.1" 500 -
        """
        return redirect('/index/')
    else:
        # 两种传值方法均可，比Django灵活一些；
        # return render_template('login.html', msg='用户名或者密码错误!')
        return render_template('login.html', **{'msg': '用户名或者密码错误！'})


@app.route('/index/')
def index():
    user_info = session.get('user_info')
    if not user_info:
        return redirect('/login/')
    else:
        return '欢迎登陆！'


@app.route('/logout/')
def logout():
    del session['user_info']
    return redirect('/login/')


if __name__ == '__main__':
    app.run()

09 Flask框架之用户管理系统示例（二）

9.1 Flask框架用户登录示例二； 

from flask import Flask, render_template, request, redirect, session

app = Flask(__name__, template_folder='templates')
# 基于app这个对象设置secret_key的值，任意设置！
app.secret_key = 'nishifdalkj4389!@#$28908'
app.debug = True
USER_DICT = {
    '1': {'name': '志军', 'age': 18},
    '2': {'name': '大伟', 'age': 48},
    '3': {'name': '美凯', 'age': 38}
}


@app.route('/login/', methods=['GET', 'POST'])
def hello_world():
    # return 'Hello World!'
    if request.method == "GET":
        return render_template('login.html')
    user = request.form.get('usr')
    pwd = request.form.get('pwd')
    if user == 'cuixiaozhao' and pwd == '123456':
        # 将用户信息放入session;
        session['user_info'] = user
        """
        RuntimeError: The session is unavailable because no secret key was set.  Set the secret_key on the application to something unique and secret.
127.0.0.1 - - [17/Sep/2018 21:02:04] "POST /login/ HTTP/1.1" 500 -
        """
        return redirect('/index/')
    else:
        # 两种传值方法均可，比Django灵活一些；
        # return render_template('login.html', msg='用户名或者密码错误!')
        return render_template('login.html', **{'msg': '用户名或者密码错误！'})


@app.route('/index/')
def index():
    user_info = session.get('user_info')
    if not user_info:
        return redirect('/login/')
    return render_template('index.html', user_dict=USER_DICT)


@app.route('/detail/')
def detail():
    user_info = session.get('user_info')
    if not user_info:
        return redirect('/login/')
    uid = request.args.get('uid')
    info = USER_DICT.get(uid)
    return render_template('detail.html', info=info)


@app.route('/logout/')
def logout():
    del session['user_info']
    return redirect('/login/')


if __name__ == '__main__':
    app.run()

10 homework

10.1 Flask装饰器、位置、url起个别名；

10.2 类似于Django中间件的东西，before_request装饰器；

10.3 上下文管理预习；

• threading.local;

• functools.wrappers;

• functools.partial;

• 面向对象中——__setarrt__;__getattr__;__delatrr__;

第2章 章节二

01 内容概要

1.1 配置文件；

1.2 路由

1.3 视图函数

1.4 请求和响应

1.5 templates模板

1.6 session（默认存储的签名的cookies中）

1.7 flash闪现

1.8 蓝图blueprint

1.9 常见的装饰器before_request

1.10 Flask中间件

02 内容回顾

2.1 装饰器；

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 10:45
# File    : 1.装饰器.py
# Author  : 天晴天朗
# Email   : [email protected]

import functools
def wapper(func):
    @functools.wraps(func)
    def inner(*args,**kwargs):
        return func(*args,**kwargs)
    return inner
'''
1、执行wapper函数，并将被装饰的函数当做参数。wapper(index)
2、将第一步的返回值，重新赋值给index = wapper（old index）

'''

#1、为什么要使用装饰器？在不改变原来函数的基础之上，对函数执行前后进行自定义操作；
@wapper
def index(a1):
    return a1 +1000

v = index(2)
print(v)
#获取函数名
print("打印函数名:",index.__name__)


@wapper
def order(a1):
    return a1+1000

print(index.__name__)
print(order.__name__)

2.2 带参数的装饰器；

2.3 什么是面向对象，为什么要使用面向对象？

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 11:06
# File    : 3.面向对象.py
# Author  : 天晴天朗
# Email   : [email protected]


""
"""
谈谈你对面向对象的认识？
封装：
    将同一类方法分为一类，方法封装到类中；
    将方法中的共同的参数封装到对象中，把共同的值封装到对象中；
"""


# 用户类实现;
class File:
    def __init__(self, a1, a2, a3, a4):
        self.a1 = a1
        self.a2 = a2
        self.a3 = a3
        self.a4 = a4

    def file_add(self):
        pass

    def file_del(self):
        pass

    def file_update(self):
        pass

    def file_fetch(self):
        pass


# 给了一些值，将数据加工，应用场景:Django自定义分页;
class Foo():
    def __init__(self, a1, a2, a3, a4, a5, a6, a7):
        self.a1 = a1
        self.a2 = a2
        self.a3 = a3
        self.a4 = a4
        self.a5 = a5
        self.a6 = a6
        self.a7 = a7

    def sum(self):
        return self.a1 + self.a2

    def reduce(self):
        return self.a5 - self.a7


obj = File(1, 2, 3, 4)
print(obj)  # <__main__.File object at 0x10bbf25c0>


class A(object):
    def __init__(self):
        self.age1 = 123
        self.a = A()


class B(object):
    def __init__(self):
        self.age2 = 123
        self.b = B()


class C(object):
    def __init__(self):
        self.age3 = 123
        self.c = C()


class D(object):
    def __init__(self):
        self.age4 = 123
        self.d = D()

03 Flask框架之配置

3.1 app.py；

from flask import Flask, render_template, redirect

app = Flask(__name__)
# Flask的配置文件这么玩耍;
app.config.from_object("settings.DevelopmentConfig")#settings后面是一个类名；


@app.route('/index/', methods=['GET', 'POST'])
def index():
    return 'Hello World!'


if __name__ == '__main__':
    app.run()

3.2 指定settings.py文件； 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 11:25
# File    : settings.py
# Author  : 天晴天朗
# Email   : [email protected]


class BaseConfig(object):
    DEBUG = False
    TESTING = False
    DATABASE_URI = 'sqllite://:memory:'


class ProductionConfig(BaseConfig):
    DATABASE_URI = 'mysql://user@production/foo'


class DevelopmentConfig(BaseConfig):
    DEBUG = True
    DATABASE_URI = 'mysql://user@development/foo'


class TestingConfig(BaseConfig):
    DEBUG = True
    DATABASE_URI = 'mysql://user@test/foo'

3.3 Flask配置文件详解； 

flask中的配置文件是一个flask.config.Config对象（继承字典）,默认配置为：
    {
        'DEBUG':                                get_debug_flag(default=False),  是否开启Debug模式；
        'TESTING':                              False,                          是否开启测试模式；
        'PROPAGATE_EXCEPTIONS':                 None,                          
        'PRESERVE_CONTEXT_ON_EXCEPTION':        None,
        'SECRET_KEY':                           None,
        'PERMANENT_SESSION_LIFETIME':           timedelta(days=31),
        'USE_X_SENDFILE':                       False,
        'LOGGER_NAME':                          None,
        'LOGGER_HANDLER_POLICY':               'always',
        'SERVER_NAME':                          None,
        'APPLICATION_ROOT':                     None,
        'SESSION_COOKIE_NAME':                  'session',
        'SESSION_COOKIE_DOMAIN':                None,
        'SESSION_COOKIE_PATH':                  None,
        'SESSION_COOKIE_HTTPONLY':              True,
        'SESSION_COOKIE_SECURE':                False,
        'SESSION_REFRESH_EACH_REQUEST':         True,
        'MAX_CONTENT_LENGTH':                   None,
        'SEND_FILE_MAX_AGE_DEFAULT':            timedelta(hours=12),
        'TRAP_BAD_REQUEST_ERRORS':              False,
        'TRAP_HTTP_EXCEPTIONS':                 False,
        'EXPLAIN_TEMPLATE_LOADING':             False,
        'PREFERRED_URL_SCHEME':                 'http',
        'JSON_AS_ASCII':                        True,
        'JSON_SORT_KEYS':                       True,
        'JSONIFY_PRETTYPRINT_REGULAR':          True,
        'JSONIFY_MIMETYPE':                     'application/json',
        'TEMPLATES_AUTO_RELOAD':                None,
    }
 
方式一：
    app.config['DEBUG'] = True
 
    PS： 由于Config对象本质上是字典，所以还可以使用app.config.update(...)
 
方式二：
    app.config.from_pyfile("python文件名称")
        如：
            settings.py
                DEBUG = True
 
            app.config.from_pyfile("settings.py")
 
    app.config.from_envvar("环境变量名称")
        环境变量的值为python文件名称名称，内部调用from_pyfile方法
 
 
    app.config.from_json("json文件名称")
        JSON文件名称，必须是json格式，因为内部会执行json.loads
 
    app.config.from_mapping({'DEBUG':True})
        字典格式
 
    app.config.from_object("python类或类的路径")
 
        app.config.from_object('pro_flask.settings.TestingConfig')
 
        settings.py
 
            class Config(object):
                DEBUG = False
                TESTING = False
                DATABASE_URI = 'sqlite://:memory:'
 
            class ProductionConfig(Config):
                DATABASE_URI = 'mysql://user@localhost/foo'
 
            class DevelopmentConfig(Config):
                DEBUG = True
 
            class TestingConfig(Config):
                TESTING = True
 
        PS: 从sys.path中已经存在路径开始写；
     
 
    PS: settings.py文件默认路径要放在程序root_path目录，如果instance_relative_config为True，则就是instance_path目录；

04 Flask框架之创建路由的两种方式

4.1 基于@app.route('/index/', methods=['GET', 'POST'])装饰器方式实现；

4.2 通过研究源代码，基于app.add_url_rule('/order/', view_func=order)实现;

from flask import Flask, render_template, redirect

app = Flask(__name__)
# Flask的配置文件这么玩耍;
app.config.from_object("settings.DevelopmentConfig")


# 添加的第一种方式,推荐使用装饰器的方式;
@app.route('/index/', methods=['GET', 'POST'])
def index():
    return '# 添加的第一种方式,推荐使用装饰器的方式;'


# 添加路由的另外一种方式;


def order():
    return '# 添加路由的第二种方式;'


app.add_url_rule('/order/', view_func=order)
if __name__ == '__main__':
    app.run()

if __name__ == '__main__':
    app.run()

05 Flask框架之反向生成URL

5.1 Flask框架之反向生成URL，（url_for,endpoint） 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 12:06
# File    : 4.反向生成URL.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Flask, render_template, redirect, url_for

app = Flask(__name__)


# endpoint&url_for不起别名默认就是函数名;
@app.route('/index/', methods=['GET', 'POST'])
def index():
    v1 = url_for('n1')
    # v2 = url_for('n1')
    # v2 = url_for('n2')
    v2 = url_for('login')
    v3 = url_for('logout')
    print(v1, v2, v3)
    return 'Index'


@app.route('/login/', methods=['GET', 'POST'], endpoint='n2')
def login():
    return 'Login'


@app.route('/logout/', methods=['GET', 'POST'], endpoint='n3')
def logout():
    return 'Logout'

06 Flask框架之自定义路由转换器

6.1 Flask之自定义路由转换器； 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 19:14
# File    : 6.Flask框架之app.route参数.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask

app = Flask(__name__)


# 从旧功能重定向至新功能页面;Js可以做重定向；meta头、js location href
@app.route('/index/', methods=['GET', 'POST'], redirect_to='/new/')
def index():
    return '旧的功能'


@app.route('/new/', methods=['GET', 'POST'])
def new():
    return '新功能'


if __name__ == '__main__':
    app.run()

6.2 常见的路由系统；

• @app.route('/user/')
• @app.route('/post/')
• @app.route('/post/')
• @app.route('/post/')
• @app.route('/login', methods=['GET', 'POST']) 

DEFAULT_CONVERTERS = {
    'default':          UnicodeConverter,
    'string':           UnicodeConverter,
    'any':              AnyConverter,
    'path':             PathConverter,
    'int':              IntegerConverter,
    'float':            FloatConverter,
    'uuid':             UUIDConverter,
}

 

def auth(func):
            def inner(*args, **kwargs):
                print('before')
                result = func(*args, **kwargs)
                print('after')
                return result

        return inner

        @app.route('/index.html',methods=['GET','POST'],endpoint='index')
        @auth
        def index():
            return 'Index'

        或
        
        def index():
            return "Index"

        self.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
        or
        app.add_url_rule(rule='/index.html', endpoint="index", view_func=index, methods=["GET","POST"])
        app.view_functions['index'] = index


        或
        def auth(func):
            def inner(*args, **kwargs):
                print('before')
                result = func(*args, **kwargs)
                print('after')
                return result

        return inner

        class IndexView(views.View):
            methods = ['GET']
            decorators = [auth, ]

            def dispatch_request(self):
                print('Index')
                return 'Index!'

        app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint



        或


        class IndexView(views.MethodView):
            methods = ['GET']
            decorators = [auth, ]

            def get(self):
                return 'Index.GET'

            def post(self):
                return 'Index.POST'


        app.add_url_rule('/index', view_func=IndexView.as_view(name='index'))  # name=endpoint




        @app.route和app.add_url_rule参数：
            rule,                       URL规则
            view_func,                  视图函数名称
            defaults=None,              默认值,当URL中无参数，函数需要参数时，使用defaults={'k':'v'}为函数提供参数
            endpoint=None,              名称，用于反向生成URL，即： url_for('名称')
            methods=None,               允许的请求方式，如：["GET","POST"]
            

            strict_slashes=None,        对URL最后的 / 符号是否严格要求，
                                        如：
                                            @app.route('/index',strict_slashes=False)，
                                                访问 http://www.xx.com/index/ 或 http://www.xx.com/index均可
                                            @app.route('/index',strict_slashes=True)
                                                仅访问 http://www.xx.com/index 
            redirect_to=None,           重定向到指定地址
                                        如：
                                            @app.route('/index/', redirect_to='/home/')
                                            或
                                            def func(adapter, nid):
                                                return "/home/888"
                                            @app.route('/index/', redirect_to=func)
            subdomain=None,             子域名访问
                                                from flask import Flask, views, url_for

                                                app = Flask(import_name=__name__)
                                                app.config['SERVER_NAME'] = 'wupeiqi.com:5000'


                                                @app.route("/", subdomain="admin")
                                                def static_index():
                                                    """Flask supports static subdomains
                                                    This is available at static.your-domain.tld"""
                                                    return "static.your-domain.tld"


                                                @app.route("/dynamic", subdomain="")
                                                def username_index(username):
                                                    """Dynamic subdomains are also supported
                                                    Try going to user1.your-domain.tld/dynamic"""
                                                    return username + ".your-domain.tld"


                                                if __name__ == '__main__':
                                                    app.run()
        

a.注册路由原理

07 Flask框架之app.route参数

7.1 app.route的常见参数; 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 19:14
# File    : 4.Flask框架之app.route参数.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask

app = Flask(__name__)


# 从旧功能重定向至新功能页面;Js可以做重定向；meta头、js location href
@app.route('/index/', methods=['GET', 'POST'], redirect_to='/new/')
def index():
    return '旧的功能'


@app.route('/new/', methods=['GET', 'POST'])
def new():
    return '新功能'


if __name__ == '__main__':
    app.run()

8 Flask框架之获取子域名的路由

8.1 域名解析之A记录；

8.2 本地域名映射之hosts文件；

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 19:14
# File    : 7.Flask框架之获取子域名.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask

app = Flask(__name__)
app.config['SERVER_NAME'] = 'www.cuixiaozhao.com:5000'


# 从旧功能重定向至新功能页面;Js可以做重定向；meta头、js location href
@app.route('/dynamic/', methods=['GET', 'POST'], subdomain='')
def sub_domain(username):
    print(username)
    return '旧的功能1'


if __name__ == '__main__':
    app.run()

09 上述内容总结

9.1 url;

9.2 methods;

9.3 endpoint;

9.4 @app.route('/index//');

9.5 url_for;

10 Flask框架之视图中添加装饰器

10.1 Flask框架中添加装饰器的注意事项；

• @装饰器的顺序

• 引入functools

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 19:14
# File    : 8.添加装饰器.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask
import functools

app = Flask(__name__)


def wapper(func):
    @functools.wraps(func)
    def inner(*args, **kwargs):
        print('before')
        return func(*args, **kwargs)

    return inner


@app.route('/xxxx/', methods=['GET', 'POST'])
@wapper
def index():
    return 'Index'


@app.route('/xxxx/', methods=['GET', 'POST'])
@wapper
def order():
    return 'Order'


if __name__ == '__main__':
    app.run()

11 Flask框架之CBV和FBV

11.1 CBV与FBV；

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 21:57
# File    : 9.Flask框架之CBV和FBV.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, redirect, render_template, views

app = Flask(__name__)
import functools


def wapper(func):
    @functools.wraps(func)
    def inner(*args, **kwargs):
        print('before')
        return func(*args, **kwargs)

    return inner


@app.route('/xxx/', methods=['GET', 'POST'])
@wapper
def index():
    return 'Index'


class IndexView(views.View):
    methods = ['GET']
    decorators = [wapper, ]

    def dispatch_request(self):
        print('Index')
        return 'Index'


app.add_url_rule('/index/', view_func=IndexView.as_view(name='index'))  # name == endpoint


# CBV方式;
class IndexView(views.MethodView):
    methods = ['GET']
    decorators = [wapper]

    def get(self):
        return 'Index.GET'

    def post(self):
        return 'Index POST'


app.add_url_rule('/index/', view_func=IndexView.as_view(name='index'))  # name = endpoint

if __name__ == '__main__':
    app.run()

12 Flask框架之请求和响应相关

12.1 Flask请求相关之request.xxx；

12.2 Flask响应相关之return和response;

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 22:13
# File    : 12.请求和响应.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Flask, render_template, request, redirect, jsonify, make_response

app = Flask(__name__)

app.config.from_object("settings.DevelopmentConfig")


@app.route('/index/', methods=['GET', 'POST'])
def index():
    # 请求相关;
    request.args

    # 响应相关;
    return ''
    return render_template()
    return redirect('/index/')
    # 返回json数据;
    return json.dumps({})  # return jsonify({})


if __name__ == '__main__':
    app.run()
"""
        # 请求相关信息;
        # request.method
        # request.args
        # request.form
        # request.values
        # request.cookies
        # request.headers
        # request.path
        # request.full_path
        # request.script_root
        # request.url
        # request.base_url
        # request.url_root
        # request.host_url
        # request.host
        # request.files
        # obj = request.files['the_file_name']
        # obj.save('/var/www/uploads/' + secure_filename(f.filename))

        # 响应相关信息;
        # return "字符串"
        # return render_template('html模板路径',**{})
        # return redirect('/index.html')

        # response = make_response(render_template('index.html'))
        # response是flask.wrappers.Response类型;
        # response.delete_cookie('key')
        # response.set_cookie('key', 'value')
        # response.headers['X-Something'] = 'A value'
        # return response
"""

13 Flask框架之模板引擎

13.1 Flask的templates模板;

13.2 通Django十分类似，具备block继承、extends；

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-18 22:23
# File    : 13.模板.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, render_template, redirect, jsonify, make_response, Markup

app = Flask(__name__)


# 全局模板——每个模板均可调用的函数;
@app.template_global()
def cxz(a1, a2):
    return a1 + a2


def input(value):
    return Markup("" % value)


def gen_input(value):
    return Markup("" % value)


@app.route('/computed/', methods=['GET', 'POST'])
def computed():
    context = {
        'k1': 123,
        'k2': [11, 22, 33],
        'k3': {'name': 'cuixiaozhao', 'age': 84},
        'k4': lambda x: x + 1,  # 用户写简单的函数;
        'k5': gen_input
    }
    return render_template('index.html', **context)


if __name__ == '__main__':
    app.run()

layout.html;

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
    <meta name="viewport" content="width=device-width, initial-scale=1">
head>
<body>
<div>头部div>
<div>
    {% block content %}
    {% endblock %}
div>
<div>底部div>
body>
html>

indexx.html;

{% extends 'layout.html' %}


{% block content %}
    <h1>{{ k1 }}h1>
    <h1>{{ k2.0 }} {{ k2[0] }}h1>
    <h1>{{ k3.name }} {{ k3['name'] }}{{ k3.get('name',19930911) }}h1>
    <h1>{{ k4 }}h1>
    <h1>{{ k5(99) }}h1>

{% endblock %}

14 Flask框架之session使用和源码流程（一）

15 Flask框架之session使用和源码流程（二）

14.1 & 15.1 之session使用和源码; 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 16:37
# File    : 1.Flask中的session.py
# Author  : 天晴天朗
# Email   : [email protected]
""
"""
Session的请求流程;
1、请求刚刚到达;
2、视图函数;
3、请求结果;
"""
from flask import Flask, session

app = Flask(__name__)

app.secret_key = 'fdjljfaljfkla'


@app.route('/index/')
def index():
    session['k1'] = 123
    return 'Index'


@app.route('/order/')
def order():
    print(session['k1'])
    return 'Order'


if __name__ == '__main__':
    app.run()
"""
1、Flask
2、RequestContext
3、Request
4、SecureCookieSessionInterface
5、SecureCookieSession(dict )
"""

16 Flask框架之before_request和after_request(一)

16.1 Flask框架中的内置装饰器之before_request和after_request; 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 17:22
# File    : 1.Flask中内置的特殊装饰器.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, render_template, redirect

app = Flask(__name__)


# before_request和after_request类似于Django中的中间件middleware；
@app.before_request
def before_req():
    print('before_request，前')


@app.before_request
def before_req1():
    print('before_request1，前')


# request之前，会添加一个reverse反转;
@app.after_request
def after_req(response):
    print('after_request, 后')
    return response


@app.after_request
def after_req1(response):
    print('after_request1, 后')
    return response


@app.route('/x1/', methods=['GET', 'POST'])
def x1():
    print('视图函数X1')
    return 'X1'


@app.route('/x2/', methods=['GET', 'POST'])
def x2():
    print('视图函数X2')
    return 'X2'


if __name__ == '__main__':
    app.run()

17 Flask框架之after_request(二)

17.1 基于before_request的用户登录示例； 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 17:22
# File    : 2.基于Flask中内置的特殊装饰器做登录验证.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, render_template, redirect, request, session

app = Flask(__name__)
app.secret_key = 'fdsjklfdjaslkjflas'


# before_request和after_request类似于Django中的中间件middleware；
@app.before_request
def check_login():
    if request.path == '/login/':
        return None
    user = session.get('user_info')
    if not user:
        return redirect('/login/')


@app.route('/login/', methods=['GET', 'POST'])
def login():
    return 'Login'


@app.route('/index/', methods=['GET', 'POST'])
def index():
    return 'Index'


if __name__ == '__main__':
    app.run()

18 Flask框架字号常见装饰器

18.1 Flask中其他常见的装饰器;

• before_first_request
• before_request
• after_request
• teardown_request
• after_this_request
• errorhandler(404)
• ...

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 17:44
# File    : 3.Flask中其他常见的装饰器.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, Request, render_template

app = Flask(__name__, template_folder='templates')
app.debug = True


@app.before_first_request
def before_first_request1():
    print('before_first_request1')


@app.before_first_request
def before_first_request2():
    print('before_first_request2')


@app.before_request
def before_request1():
    Request.nnn = 123
    print('before_request1')


@app.before_request
def before_request2():
    print('before_request2')


@app.after_request
def after_request1(response):
    print('before_request1', response)
    return response


@app.after_request
def after_request2(response):
    print('before_request2', response)
    return response


@app.errorhandler(404)
def page_not_found(error):
    return 'This page does not exist', 404


@app.template_global()
def sb(a1, a2):
    return a1 + a2


@app.template_filter()
def db(a1, a2, a3):
    return a1 + a2 + a3


@app.route('/')
def hello_world():
    return render_template('index.html')


if __name__ == '__main__':
    app.run()

19 上述内容总结

19.1小结:

　　19.1.1配置文件

　　19.1.2路由

　　19.1.3视图之CBV（class-based views ）&FBV（function base view）

　　19.1.4request

　　19.1.5response = make_response(...)

　　19.1.6模板

　　19.1.7session

　　19.1.8常见的装饰器

20 Flask之闪现

20.1 Flask之消息闪现flask& get_flashed_messages；（内部原理基于session实现）

 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 18:03
# File    : 1.Flask之消息闪现flush.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Flask, session, flash, get_flashed_messages

app = Flask(__name__)
app.secret_key = 'fdjslkjflkafdaklfjdlakfj'


# # 生成session;
# @app.route('/x1/', methods=['GET', 'POST'])
# def login():
#     session['mgs'] = 'cuixiaozhao'
#     return '视图函数1'
#
#
# # 销毁session;;
# @app.route('/x2/', methods=['GET', 'POST'])
# def index():
#     msg = session.pop('msg')
#     print(msg)
#     return '视图函数2'
# 消息闪现之flask生成session;
@app.route('/x1/', methods=['GET', 'POST'])
def login():
    flash('cuixiaozhao', category='x1')
    flash('cuixiaozhao', category='x2')
    return '视图函数1'


# 消息闪现之flask销毁session;;
@app.route('/x2/', methods=['GET', 'POST'])
def index():
    data = get_flashed_messages(category_filter=['x1', 'x2'])
    print(data)
    return '视图函数2'


if __name__ == '__main__':
    app.run()

21 Flask中间件

21.1 Flask中自定义中间件; 

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 18:13
# File    : 1.Flask之中间件.py
# Author  : 天晴天朗
# Email   : [email protected]

from flask import Flask

app = Flask(__name__)
app.secret_key = 'fjaljfdklajfkdasl'


@app.route('/x2', methods=['GET', 'POST'])
def index():
    return 'x2'


class MiddleWare(object):
    def __init__(self, old_wsgi_app):
        self.old_wsgi_app = old_wsgi_app

    def __call__(self, *args, **kwargs):
        print('before')
        obj = self.old_wsgi_app(*args, **kwargs)
        print('after')
        return obj


if __name__ == '__main__':
    app.wsgi_app = MiddleWare(app.wsgi_app)
    app.run()
"""
1、执行app.__call__方法;
2、在调用app.wsgi_app方法;
"""

22 Flask框架之蓝图（一）

　　简单来说，Blueprint 是一个存储操作方法的容器，这些操作在这个Blueprint 被注册到一个应用之后就可以被调用，Flask 可以通过Blueprint来组织URL以及处理请求。Flask使用Blueprint让应用实现模块化，在Flask中，Blueprint具有如下属性：

• 一个应用可以具有多个Blueprint；
• 可以将一个Blueprint注册到任何一个未使用的URL下比如 “/”、“/sample”或者子域名；
• 在一个应用中，一个模块可以注册多次；
• Blueprint可以单独具有自己的模板、静态文件或者其它的通用操作方法，它并不是必须要实现应用的视图和函数的；
• 在一个应用初始化时，就应该要注册需要使用的Blueprint；

22.1 创建Flask项目ProFlask;

22.2 自定义文件存储目录；

__init__.py;

from flask import Flask

app = Flask(__name__)

# @app.route('/index/')
# def index():
#     pass


from .views import account
from .views import admin
from .views import user

app.register_blueprint(account.ac)
app.register_blueprint(admin.ad)
app.register_blueprint(user.us)

accounts.py;

# -*- coding:utf-8 -*-
# Project: Pro_Flask 
# Software: PyCharm
# Time    : 2018-09-19 19:08
# File    : account.py
# Author  : 天晴天朗
# Email   : [email protected]

from flask import Flask, render_template
# 蓝图Blueprint;
from flask import Blueprint

ac = Blueprint('ac', __name__)


@ac.route('/login/')
def login():
    #return 'Login'
    return render_template('login.html')


@ac.route('/logout/')
def logout():
    return 'Logout' 

23 Flask框架之蓝图（二）

23.1 蓝图的三大作用（相当于Django中的app）；

• 目录结构的划分；
• URL的划分；
• 给每一类URL添加before_request

24 拓展知识：pipreqs工具

24.1 项目依赖；

24.2 拿到代码启动不起来；

24.3 pip3 install pipreqs;（自动查找项目所需要的依赖包及版本号）；

24.4 pipreqs ./ --force 强制生成依赖文件；

24.5 pip3 install -i requirements.txt 安装依赖文件；

25 拓展知识：函数和方法

25.1 什么是函数？

25.2 什么是方法？

# -*- coding:utf-8 -*-
# Project: Day123 
# Software: PyCharm
# Time    : 2018-09-19 20:40
# File    : 1.函数和方法的区别.py
# Author  : 天晴天朗
# Email   : [email protected]


from types import MethodType, FunctionType


class Foo(object):
    def fetch(self):
        pass


print(isinstance(Foo.fetch, MethodType))  # False
print(isinstance(Foo.fetch, FunctionType))  # True

obj = Foo()
print(obj.fetch)  # >
print(isinstance(obj.fetch, MethodType))  # False
print(isinstance(Foo.fetch, FunctionType))  # True
"""
类、对象、方法、函数可以➕()；
方法和函数的区别：被谁来调用！
"""

第3章 章节三

01 内容概要

1.1 Flask提升逼格的时候；

1.2 Flask的上下文管理；

1.3 threading.local;

1.4 数据库连接池;

02 内容回顾

2.1 常用的Linux命令（100+）；

2.2 常见算法搞定；

2.3 数据库连接池；

2.4 面向对象的特殊方法；

• call;
• new;
• and;
• equal;
• next;
• dict;

2.5 functools；

• functools.partial();
• 装饰器的应用场景；-Flask路由以及before_request、登录认证、Django缓存\CSRF_TOKEN；

2.6 Flask中的蓝图Blueprint;

2.7 Flask中的session;

03 threading.local学习

3.1 threading.local初识；

# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-19 22:40
# File    : 1.ThreadingLocal.py
# Author  : 天晴天朗
# Email   : [email protected]

from threading import local
from threading import Thread
import time

# 特殊的对象;
xiaozhao = local()


# xiaozhao = -1


def task(arg):
    # global xiaozhao

    xiaozhao.value = arg
    time.sleep(2)
    print(xiaozhao.value)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

04 自定义Local思路

05 自定义Local对象（基于函数）

5.1 基于get_ident实现；

 

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:11
# File    : 3.自定义Local对象（基于函数）.py
# Author  : 天晴天朗
# Email   : [email protected]

from threading import get_ident, Thread
import time

storage = {}


def set(k, v):
    ident = get_ident()
    if ident in storage:
        storage[ident][k] = v
    storage[ident] = {k: v}


def get(k):
    ident = get_ident()
    return storage[ident][k]


def task(arg):
    set('val', arg)
    print(storage)
    time.sleep(2)
    v = get('val')
    print(v)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

06 自定义Local对象（基于面向对象）

6.1 基于面向对象basic；

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:20
# File    : 4.自定义Local对象(基于面向对象).py
# Author  : 天晴天朗
# Email   : [email protected]
from threading import get_ident
from threading import Thread


class Local(object):
    storage = {}

    def set(self, k, v):
        ident = get_ident()
        if ident in Local.storage:
            Local.storage[ident][k] = v
        else:
            Local.storage[ident] = {k: v}

    def get(self, k):
        ident = get_ident()
        return Local.storage[ident][k]

obj = Local()
def task(arg):
    obj.set('val', arg)
    v = obj.get('val')
    print(v)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

6.2 基于面向对象优化版；

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:20
# File    : 5.自定义Local对象(基于面向对象优化版 ).py
# Author  : 天晴天朗
# Email   : [email protected]
from threading import get_ident
from threading import Thread


class Local(object):

    def __setattr__(self, k, v):
        # self.storage = {}
        object.__setattr__(self, 'storage', {})
        ident = get_ident()
        if ident in self.storage:
            self.storage[ident][k] = v
        else:
            self.storage[ident] = {k: v}


def __getattr__(self, item):
    ident = get_ident()
    return self.storage[ident][item]


obj = Local()
obj1 = Local()


def task(arg):
    obj.val = arg
    obj1.val = arg
    print(obj.val)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

6.3 基于面向对象升级版；

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:20
# File    : 4.自定义Local对象(基于面向对象).py
# Author  : 天晴天朗
# Email   : [email protected]
from threading import get_ident
from threading import Thread


class Local(object):
    storage = {}

    def __setattr__(self, k, v):
        ident = get_ident()
        if ident in Local.storage:
            Local.storage[ident][k] = v
        else:
            Local.storage[ident] = {k: v}

    def __getattr__(self, item):
        ident = get_ident()
        return Local.storage[ident][item]


obj = Local()


def task(arg):
    obj.val = arg
    print(obj.val)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

6.4 基于面向对象greenlet版本； 

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:20
# File    : 7.自定义Local对象(基于greenlet).py
# Author  : 天晴天朗
# Email   : [email protected]

try:
    from greenlet import getcurrent as get_ident
except Exception as e:
    from threading import get_ident
from threading import Thread


class Local(object):
    storage = {}

    def __setattr__(self, k, v):
        ident = get_ident()
        if ident in Local.storage:
            Local.storage[ident][k] = v
        else:
            Local.storage[ident] = {k: v}

    def __getattr__(self, item):
        ident = get_ident()
        return Local.storage[ident][item]


obj = Local()


def task(arg):
    obj.val = arg
    print(obj.val)


for i in range(10):
    t = Thread(target=task, args=(i,))
    t.start()

07 Flask上下文管理之本质分析 

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Threading 
# Software: PyCharm
# Time    : 2018-09-20 09:45
# File    : 1.Flask源码分析上下文管理.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello_world():
    return 'cuixiaozhao!'


if __name__ == '__main__':
    app.__call__
    app.run()

    ""
"""
1、第一个阶段：将ctx(request，session)放到Local对象;
2、第二阶段:视图函数导入：request、session；
3、请求处理完毕：
    -获取session并保存到cookie；
    -将ctx删除；
"""

08 Flask上下文管理之请求到处理阶段

8.1 Flask中的session是何时创建何时销毁的？request_context，localstack、local；

09 Flask上下文管理之视图调用阶段

9.1 调用阶段；

10 Flask上下文管理之视图调动阶段和结束阶段

10.1 视图调用阶段和结束阶段；

11 问题来了

11.1 Flask中一共有几个Local和Local对象？

都是2个；

12 Flask中的g到底是什么呢？生命周期？

12.1 Flask的g对象范围；

13 内容补充：面向对象的私有字段

13.1 私有字段不建议去调动；

• obj = Foo()
• obj._Foo_age(类名前加下划线)

14 homework

14.1 按照组为单位，画图-类的调用关系图；

第4章 章节四

01 内容概要

1.1 flask-session；

1.2 单独模块-数据库连接池DBUtils；

1.3 原生SQL（基于pymysql）还是ORM好？！

1.4 wtforms（任何Django框架都可使用）；

1.5 SQLAchemy、flask-sqlachemy；

1.6 flask-script；

1.7 flask-migrate；

02 内容回顾

2.1 谈谈Django和Flask的认识？

2.2 Django的上下文管理机制？

2.3 ctx = RequestContext(request,session)

2.4 Local对象的作用？

• 看过Local源码，和Threading.local相似但又有不同之处；
• 不同之处在于，Local中基于greenlet获取唯一表示，颗粒度更细；

2.5 为什么使用Localstack？对Local对象中的数据进行操作。

2.6 上下文管理分为两个-请求上下文和App上下文

2.7 什么是g？一次请求周期内的全局变量。

2.8 获取session和g的流程。

2.9 Flask中的技术点。

• 反射；
• 面向对象-封装、继承和多态；
• __dict__；
• 线程相关的东西-threading.local；
• 自己写一个类+列表，实现一个栈（基于Localstack实现栈）；

03 路飞学城补充：视频播放授权

4.1 CC视频播放授权；

04 flask-session组件使用和原理（一）

 4.1 flask-session；

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 16:14
# File    : 1.flask_session.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask, session
from flask_session import RedisSessionInterface

app = Flask(__name__)
app.secret_key = 'fdahfdafdajfalk'

# 默认session保存操作；
# from flask.sessions import SecureCookieSessionInterface

# app.session_interface = SecureCookieSessionInterface()

# 使用Redis保存session;
from flask.ext.session import Session
from redis import Redis

app.config['SESSION_TYPE'] = 'redis'
app.config['SESSION_REDIS'] = Redis(host='192.168.0.94', port='6379')
app.session_interface = RedisSessionInterface(
    redis=Redis(host='127.0.0.1', port=6379),
    key_prefix='flaskxxxx'

)


@app.route('/login/')
def login():
    session['k1'] = 123
    return 'Login'


@app.route('/index/')
def index():
    v = session['k1']
    print(v)
    return 'Index'


if __name__ == '__main__':
    app.run()

05 flask-session组件使用和原理（二）

5.1 原理难，实现的机制难，使用起来比较容易，但是要想学好， 必须懂原理；

5.2 MTV 和MVC设计模式；

• MTV-Model、Templates、View；
• MVC-Model、View、Controller；

5.3 自定义Flask项目Flask_Session；

__init__.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 16:46
# File    : __init__.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask
from .views import account
from .views import home


def create_app():
    app = Flask(__name__)
    app.config.from_object('settings.DevelopmentConfig')
    app.register_blueprint(account.account)
    app.register_blueprint(home.home)
    return app

manage.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 16:46
# File    : manage.py
# Author  : 天晴天朗
# Email   : [email protected]

from Flask_Session import create_app

app = create_app()

if __name__ == '__main__':
    app.run()

account.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 16:53
# File    : account.py
# Author  : 天晴天朗
# Email   : [email protected]

from flask import Blueprint, render_template, request, session, redirect
from uuid import uuid4

account = Blueprint('account', __name__)


@account.route('/login/', methods=['GET', 'POST'])
def login():
    if request.method == "GET":
        return render_template("login.html")
    user = request.form.get('user')
    pwd = request.form.get('pwd')
    if user == "cxz" and pwd == "123":
        uid = str(uuid4())
        session.permanent = True
        session['user_info'] = {'id': uid, 'name': user}
        return redirect('/index/')
    else:
        return render_template('login.html', msg='用户名或者密码错误！')

home.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 17:33
# File    : home.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Blueprint, render_template, request, session, redirect

home = Blueprint('home', __name__)


@home.route('/index/', methods=['GET', 'POST'])
def index():
    user_info = session.get('user_info')  # {'k1':1,'k2':2}
    print("原来的值", user_info)
    session['user_info']['k1'] = 19939
    user_info = session.get('user_info')
    print("修改之后的值", user_info)
    # session['modified'] = True,在配置文件中使用SESSION_REFRESH_EACH_REQUEST代替;
    return 'Index'


@home.route('/test/')
def test():
    user_info = session.get('user_info')
    print(user_info)
    return 'Test'

settings.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 17:28
# File    : settings.py
# Author  : 天晴天朗
# Email   : [email protected]
from datetime import timedelta


class Config(object):
    DEBUG = True
    TESTING = False
    DATABASE_URI = 'sqlite://:memory'
    SECRET_KEY = 'fjdksjfdasljflksd'
    PERMANENT_SESSION_LIFETIME = timedelta(minutes=20)
    SESSION_REFRESH_EACH_REQUEST = True


class ProductionConfig(Config):
    pass


class DevelopmentConfig(Config):
    pass


class TestingConfig(Config):
    pass

06 flask-session组件使用和原理（三）

6.1 将数据存储至Redis；

settings.py;

 

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 17:28
# File    : settings.py
# Author  : 天晴天朗
# Email   : [email protected]
from datetime import timedelta
from redis import Redis


class Config(object):
    DEBUG = True
    TESTING = False
    DATABASE_URI = 'sqlite://:memory'
    SECRET_KEY = 'fjdksjfdasljflksd'
    PERMANENT_SESSION_LIFETIME = timedelta(minutes=20)
    SESSION_REFRESH_EACH_REQUEST = True
    SESSION_TYPE = "redis"
    # SESSION_REDIS = Redis(host='127.0.0.1',port='6379')


class ProductionConfig(Config):
    SESSION_REDIS = Redis(host='127.0.0.1', port='6379')


class DevelopmentConfig(Config):
    SESSION_REDIS = Redis(host='127.0.0.1', port='6379')


class TestingConfig(Config):
    SESSION_REDIS = Redis(host='127.0.0.1', port='6379')

 

__init__.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 16:46
# File    : __init__.py
# Author  : 天晴天朗
# Email   : [email protected]
from flask import Flask
from .views import account
from .views import home
# from flask.ext.session import Session
from flask_session import Session


def create_app():
    app = Flask(__name__)
    app.config.from_object('settings.DevelopmentConfig')
    app.register_blueprint(account.account)
    app.register_blueprint(home.home)
    # 将Session替换成Redis;
    Session(app)
    return app

 

6.2 Mac版本的Redis可视化工具redis desktop manager的使用；

07 flask-session组件使用和原理（四）

7.1 flask-session的作用：将默认保存的签名cookie中的值保存到Redis、memcached、file、MongoDB、SQLAchemy；

7.2 配置方法；

app.config['SESSION_TYPE'] = 'redis'

app.config['SESSION_REDIS'] = Redis(host = '127.0.0.1',port=6379)

7.3 替换方式；

from flask_session import Session

Session(app)

7.4 注意事项：session中存储的是字典，修改字典内部元素时候，会造成数据不更新；

• modified = True ，默认值为False
• SESSION_REFRESH_EACH_REQUEST = True and session.permanent = True (Redis中默认)

08 基于pymysql实现用户登录

8.1 基于pymysql；

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 20:13
# File    : sql.py
# Author  : 天晴天朗
# Email   : [email protected]
import pymysql


class SQLHelper(object):
    @staticmethod
    def open():
        conn = pymysql.connect(host='mysql123.cuixiaozhao.com', port=3306, user='root', passwd='Tqtl911!@%*)',
                               db='flask_session')
        cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
        return conn, cursor

    @staticmethod
    def close(conn, cursor):
        conn.commit()
        cursor.close()
        conn.close()

    @classmethod
    def fetch_one(cls, sql, args):
        # cursor.execute("select id,name from users where name = %s and pwd = %s", ['cxz', '123', ])
        conn, cursor = cls.open()
        cursor.execute(sql, args)
        obj = cursor.fetchone()
        cls.close(conn, cursor)
        return obj

    @classmethod
    def fetch_all(cls, sql, args):
        conn, cursor = cls.open()
        cursor.execute(sql, args)
        obj = cursor.fetchall()
        cls.close(conn, cursor)
        return obj

8.2 pymysql的练习和使用； 

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-20 19:53
# File    : MySQL数据库练习.py
# Author  : 天晴天朗
# Email   : [email protected]


import pymysql

conn = pymysql.connect(host='x.x.x.x', port=3306, user='root', passwd='Tqtl911!@%*)', db='flask_session')
cursor = conn.cursor(cursor=pymysql.cursors.DictCursor)
cursor.execute("select id,name from users where name = %s and pwd = %s", ['cxz', '123', ])
obj = cursor.fetchone()
conn.commit()
cursor.close()

conn.close()

print(obj)

09 基于数据库连接池实现用户登录(出bug)

9.1 DBUtils模块初识；

　　DBUtils是Python的一个用于实现数据库连接池的模块。

pool.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-21 10:26
# File    : pool.py
# Author  : 天晴天朗
# Email   : [email protected]
import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
from manage import app

POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块；
    maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数；
    mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建；
    maxcached=5,  # 链接池中最多闲置的链接；
    maxshared=3,
    # 链接池中最多共享的链接数量，0和None表示全部共享。PS: Useless无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错；
    maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制；
    setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    host='mysql.cuixiaozhao.com',
    port=3306,
    user='root',
    password='Tqtl911!@%*)',
    database='flask_session',
    charset='utf8'
)

9.2 模式一：模式一：为每个线程创建一个连接，线程即使调用了close方法，也不会关闭，只是把连接重新放到连接池，供自己线程再次使用。当线程终止时，连接自动关闭。

POOL = PersistentDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    closeable=False,
    # 如果为False时， conn.close() 实际上被忽略，供下次使用，再线程关闭时，才会自动关闭链接。如果为True时， conn.close()则关闭链接，那么再次调用pool.connection时就会报错，因为已经真的关闭了连接（pool.steady_connection()可以获取一个新的链接）
    threadlocal=None,  # 本线程独享值得对象，用于保存链接对象，如果链接对象被重置
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)

def func():
    conn = POOL.connection(shareable=False)
    cursor = conn.cursor()
    cursor.execute('select * from tb1')
    result = cursor.fetchall()
    cursor.close()
    conn.close()

func()

9.3 模式二：模式二：创建一批连接到连接池，供所有线程共享使用。

import time
import pymysql
import threading
from DBUtils.PooledDB import PooledDB, SharedDBConnection
POOL = PooledDB(
    creator=pymysql,  # 使用链接数据库的模块
    maxconnections=6,  # 连接池允许的最大连接数，0和None表示不限制连接数
    mincached=2,  # 初始化时，链接池中至少创建的空闲的链接，0表示不创建
    maxcached=5,  # 链接池中最多闲置的链接，0和None不限制
    maxshared=3,  # 链接池中最多共享的链接数量，0和None表示全部共享。PS: 无用，因为pymysql和MySQLdb等模块的 threadsafety都为1，所有值无论设置为多少，_maxcached永远为0，所以永远是所有链接都共享。
    blocking=True,  # 连接池中如果没有可用连接后，是否阻塞等待。True，等待；False，不等待然后报错
    maxusage=None,  # 一个链接最多被重复使用的次数，None表示无限制
    setsession=[],  # 开始会话前执行的命令列表。如：["set datestyle to ...", "set time zone ..."]
    ping=0,
    # ping MySQL服务端，检查是否服务可用。# 如：0 = None = never, 1 = default = whenever it is requested, 2 = when a cursor is created, 4 = when a query is executed, 7 = always
    host='127.0.0.1',
    port=3306,
    user='root',
    password='123',
    database='pooldb',
    charset='utf8'
)


def func():
    # 检测当前正在运行连接数的是否小于最大链接数，如果不小于则：等待或报raise TooManyConnections异常
    # 否则
    # 则优先去初始化时创建的链接中获取链接 SteadyDBConnection。
    # 然后将SteadyDBConnection对象封装到PooledDedicatedDBConnection中并返回。
    # 如果最开始创建的链接没有链接，则去创建一个SteadyDBConnection对象，再封装到PooledDedicatedDBConnection中并返回。
    # 一旦关闭链接后，连接就返回到连接池让后续线程继续使用。
    conn = POOL.connection()

    # print(th, '链接被拿走了', conn1._con)
    # print(th, '池子里目前有', pool._idle_cache, '\r\n')

    cursor = conn.cursor()
    cursor.execute('select * from tb1')
    result = cursor.fetchall()
    conn.close()


func()

9.4 补充说明; 如果没有连接池，使用pymysql来连接数据库时，单线程应用完全没有问题，但如果涉及到多线程应用那么就需要加锁，一旦加锁那么连接势必就会排队等待，当请求比较多时，性能就会降低了。

10 解决bug（一）

11 解决bug（二）

12 数据库连接池总结

12.1 每一个线程创建一个连接，关闭（默认不关闭），线程终止时，才关闭连接；

12.2 创建共享连接池；

12.3 应用；只要写原生sql，使用了pymysql就得使用数据库连接池DBUtils；

13 WTforms介绍以及用户登录示例

13.1 WTform安装；

13.2 WTform的使用；

 

#!/usr/bin/env python
# -*- coding:utf-8 -*-
from flask import Flask, render_template, request, redirect
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')
app.debug = True


class LoginForm(Form):
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired(message='用户名不能为空.'),
            validators.Length(min=6, max=18, message='用户名长度必须大于%(min)d且小于%(max)d')
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'}

    )
    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.'),
            validators.Length(min=8, message='用户名长度必须大于%(min)d'),
            validators.Regexp(regex="^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[$@$!%*?&])[A-Za-z\d$@$!%*?&]{8,}",
                              message='密码至少8个字符，至少1个大写字母，1个小写字母，1个数字和1个特殊字符')

        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )



@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'GET':
        form = LoginForm()
        return render_template('login.html', form=form)
    else:
        form = LoginForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('login.html', form=form)

if __name__ == '__main__':
    app.run()

app.py

 

index.html;

!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>登录h1>
<form method="post">
    
    <p>{{form.name.label}} {{form.name}} {{form.name.errors[0] }}p>

    
    <p>{{form.pwd.label}} {{form.pwd}} {{form.pwd.errors[0] }}p>
    <input type="submit" value="提交">
form>
body>
html>

14 WTforms用户注册示例

14.1 基于WTforms做用户注册验证；

app.py;

#!/usr/bin/python3
# -*- coding:utf-8 -*-
# Project: Flask_Session 
# Software: PyCharm
# Time    : 2018-09-21 15:11
# File    : register.py
# Author  : 天晴天朗
# Email   : [email protected]


from flask import Flask, render_template, request, redirect, Blueprint
from wtforms import Form
from wtforms.fields import core
from wtforms.fields import html5
from wtforms.fields import simple
from wtforms import validators
from wtforms import widgets

app = Flask(__name__, template_folder='templates')
app.debug = True


class RegisterForm(Form):
    name = simple.StringField(
        label='用户名',
        validators=[
            validators.DataRequired('用户名不能为空！')
        ],
        widget=widgets.TextInput(),
        render_kw={'class': 'form-control'},
        default='alex'
    )

    pwd = simple.PasswordField(
        label='密码',
        validators=[
            validators.DataRequired(message='密码不能为空.')
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    pwd_confirm = simple.PasswordField(
        label='重复密码',
        validators=[
            validators.DataRequired(message='重复密码不能为空.'),
            validators.EqualTo('pwd', message="两次密码输入不一致")
        ],
        widget=widgets.PasswordInput(),
        render_kw={'class': 'form-control'}
    )

    email = html5.EmailField(
        label='邮箱',
        validators=[
            validators.DataRequired(message='邮箱不能为空.'),
            validators.Email(message='邮箱格式错误')
        ],
        widget=widgets.TextInput(input_type='email'),
        render_kw={'class': 'form-control'}
    )

    gender = core.RadioField(
        label='性别',
        choices=(
            (1, '男'),
            (2, '女'),
        ),
        coerce=int
    )
    city = core.SelectField(
        label='城市',
        choices=(
            ('bj', '北京'),
            ('sh', '上海'),
        )
    )

    hobby = core.SelectMultipleField(
        label='爱好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        coerce=int
    )

    favor = core.SelectMultipleField(
        label='喜好',
        choices=(
            (1, '篮球'),
            (2, '足球'),
        ),
        widget=widgets.ListWidget(prefix_label=False),
        option_widget=widgets.CheckboxInput(),
        coerce=int,
        default=[1, 2]
    )

    def __init__(self, *args, **kwargs):
        super(RegisterForm, self).__init__(*args, **kwargs)
        self.favor.choices = ((1, '篮球'), (2, '足球'), (3, '羽毛球'))

    def validate_pwd_confirm(self, field):
        """
        自定义pwd_confirm字段规则，例：与pwd字段是否一致
        :param field:
        :return:
        """
        # 最开始初始化时，self.data中已经有所有的值

        if field.data != self.data['pwd']:
            # raise validators.ValidationError("密码不一致") # 继续后续验证
            raise validators.StopValidation("密码不一致")  # 不再继续后续验证


@app.route('/register', methods=['GET', 'POST'])
def register():
    if request.method == 'GET':
        form = RegisterForm(data={'gender': 1})
        return render_template('register.html', form=form)
    else:
        form = RegisterForm(formdata=request.form)
        if form.validate():
            print('用户提交数据通过格式验证，提交的值为：', form.data)
        else:
            print(form.errors)
        return render_template('register.html', form=form)


if __name__ == '__main__':
    app.run()

# app.py

register.html;

DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Titletitle>
head>
<body>
<h1>用户注册h1>
<form method="post" novalidate style="padding:0  50px">
    {% for item in form %}
    <p>{{item.label}}: {{item}} {{item.errors[0] }}p>
    {% endfor %}
    <input type="submit" value="提交">
form>
body>
html>

15 内容总结

15.1 WTforms总结；

WTForms是一个支持多个web框架的form组件，主要用于对用户请求数据进行验证。

16 homework

16.1 补充了路飞学城CC授权播放；

16.2 flask-session的用法以及Redis的使用；

16.3 pymysql以及数据库连接池DBUtils；

16.4 WTforms；

16.5 Flask的上下文管理以及源码

16.6 flask-session；

 

 

转载于:https://www.cnblogs.com/tqtl911/p/9581953.html