精华内容
下载资源
问答
  • from datetime import timedelta from flask import session, app @app.before_request def make_session_permanent(): session.permanent = True app.permanent_session_lifetime = timedelta(minutes=5)
    from datetime import timedelta
    from flask import session,Flask
    app=Flask(__name__)
    @app.before_request
    def before_request():
        session.permanent = True
        app.permanent_session_lifetime = timedelta(minutes=5)
    

    设置5分钟后过期

    展开全文
  • python tornado session

    2019-11-12 17:04:43
    main.py,此处使用的是内存方式redis和memecahe修改driver和后面的设置 import os from tornado import ioloop import tornado import tornado.httpserver import tornado.web app_handlers = [ (r'/test', ...

    main.py ,此处使用的是内存方式redis和memecahe修改driver和后面的设置

    import os
    from tornado import ioloop
    import tornado
    import tornado.httpserver
    import tornado.web
    
    app_handlers = [
        (r'/test', TestHandler),
        (r'/', IndexHandler),
    ]
    
    class Application(tornado.web.Application):
        def __init__(self):
            parent_path = os.path.dirname(__file__)
            handlers = app_handlers
            settings = dict(
                debug=True,
            )
            session_settings = dict(
                driver="memory",
                driver_settings=dict(
                    host=self,
                ),
                sid_name='torndsession-mem',  # default is msid.
                session_lifetime=20* 60,  # default is 1200 seconds.
                force_persistence=True,
            )
            settings.update(session=session_settings)
            tornado.web.Application.__init__(self, handlers=handlers, template_path=os.path.join(parent_path, 'template'),
                                             static_path=os.path.join(parent_path, 'static'), **settings)
    
    
    if __name__ == '__main__':
        try:
            # 初始化Server
            http_server = tornado.httpserver.HTTPServer(Application())
            http_server.listen(8800)
            tornado.ioloop.IOLoop.instance().start()
    
        except Exception as err:
            print("error:", err)

    base_request.py

    # -*- coding: utf-8 -*-
    from sqlalchemy.orm import scoped_session, sessionmaker
    from common.dbutils import engine
    from torndsession.sessionhandler import SessionBaseHandler
    from common.auth_utils import token_check
    # 以下导入内容此处未用到,但在pyinstaller打包的时候会用,勿删
    # import torndsession.memcachedsession
    
    __author__ = 'Ennis'
    
    
    class BaseHttpHandler(SessionBaseHandler):
    
        def __init__(self, application, request, **kwargs):
            super(BaseHttpHandler, self).__init__(application, request, **kwargs)
            self.db = scoped_session(sessionmaker(bind=engine))
            self._session = self.session.session
    
        def data_received(self, chunk):
            pass
    
        def write(self, chunk):
            super(BaseHttpHandler, self).write(chunk)
    
        def on_finish(self):
            self.db.rollback()
            self.db.close()
    
        def session_get(self, key, default=None):
            if key in self.session:
                return self._session[key]
            else:
                return default
    
    
    @token_check
    class ApiRequestHandler(BaseHttpHandler):
        def __init__(self, application, request, **kwargs):
            super(ApiRequestHandler, self).__init__(application, request, **kwargs)
    
            if 'token' in self.session:
                self.session['token'] = self.session['token']
                self.session.flush()
    
        def data_received(self, chunk):
            pass

     auth_utils.py

    # -*- coding: utf-8 -*-
    __author__ = 'Ennis'
    
    
    def token_check(handler_class):
        def wrap_execute(handler_execute):
            def require_auth(handler, kwargs):
                """
                :param handler:
                :param kwargs:
                :return:
    
                # I've pulled this out just for clarity, but you could stick
                # it in _execute if you wanted.  It returns True iff
                # credentials were provided.  (The end of this function might
                # be a good place to see if you like their username and
                # password.)
                """
                if 'token' not in handler.session:
                    handler.set_status(401)
                    handler._transforms = []
                    handler.write('session expired, please login again')
                    handler.finish()
                    return False
    
                return True
    
            def _execute(self, transforms, *args, **kwargs):
                """
                :param self:
                :param transforms:
                :param args:
                :param kwargs:
                :return:
    
                # Since we're going to attach this to a RequestHandler class,
                # the first argument will wind up being a reference to an
                # instance of that class.
                """
                if not require_auth(self, kwargs):
                    return False
                return handler_execute(self, transforms, *args, **kwargs)
    
            return _execute
    
        handler_class._execute = wrap_execute(handler_class._execute)
        return handler_class

    api使用,登录继承base不检查session,其他接口需要检查session继承apibase

    
    class login(BaseHttpHandler):
        def post(self):
            msg_body = self.request.body.decode()
            msg = json.loads(msg_body)
            phone = msg["phone"]
            password = hashlib.md5(msg["password"].encode(encoding='UTF-8')).hexdigest()
           
            logging.info('user login success, user_id = %s', phone + password)
            self.session['token'] = phone + password
            self.session.flush()
            self.write(json.dumps({"result": 1}))
    
    
    
    class getUserInfo(ApiRequestHandler):
        def post(self):
            msg_body = self.request.body.decode()
            msg = json.loads(msg_body)
            phone = msg["phone"]
       
            if user == None:
                self.write(json.dumps({"result": 0, "message": "该用户信息不存在"}))
                return

    redis设置方式

    session_settings = dict(
                driver="redis",
                driver_settings=dict(
                    host='localhost',
                    port=6379,
                    db=0,
                    max_connections=1024,
                )
                session_lifetime=10,
                force_persistence=True,
            )

     

    展开全文
  • PythonSession会话

    2020-11-12 15:51:05
    当我们在爬取某些页面的时候,服务器往往...虽然我们再之前可以通过requests.utils.dict_from_cookiejar(r.cookies)提取到这个响应信息中设置的新cookie,但在下一个请求中再携带这个数据的过程较为麻烦,所以requests

    当我们在爬取某些页面的时候,服务器往往会需要cookie,而想要得到cookie 就需要先访问某个URL进行登录,服务器接收到请求之后验证用户名以及密码在登录成功的情况下会返回一个响应,这个响应的header中一般会有一个set-cookie的信息,它对应的值就是要设置的cookie信息。

    虽然我们再之前可以通过requests.utils.dict_from_cookiejar(r.cookies)提取到这个响应信息中设置的新cookie,但在下一个请求中再携带这个数据的过程较为麻烦,所以requests有个高级的方式“会话Session”

    一,Session的作用

    会话Session能够跨请求保持某些参数,也会在同一个 Session 实例发出的所有请求之间保持 cookie

    会话保持有两个内涵:

    • 保存cookie,下一次请求会自动带上前一次的cookie
    • 实现和服务端的长连接,加快请求速度

    二,使用方法

    # 1. 创建一个session实例对象
    s = requests.Session()
    
    # 2. 使用上一步创建的对象发起请求
    r = s.get(url1, headers)
    r = s.get(url2, headers)
    r = s.get(url3, headers)
    r = s.get(url4, headers)
    

    session对象在请求了一个网站后,对方服务器设置在本地的cookie会保存在session对象中,下一次再使用session对象请求对方服务器的时候,会自动带上前一次的cookie

    示例:

    import requests
    
    s = requests.Session()
    
    headers = {
        "User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1"
    }
    
    # 发送第一个请求
    r = s.get('https://www.baidu.com', headers=headers)
    print("第一次请求的请求头为:", r.request.headers)
    print("响应头:", r.headers)
    print("设置的cookie为:", requests.utils.dict_from_cookiejar(r.cookies))
    
    # 发送第二个请求()
    r = s.get("https://www.baidu.com")
    print("第二次请求的请求头为:", r.request.headers)
    

    效果如下:
    在这里插入图片描述

    展开全文
  • 应用名/views.py(视图,视图函数): from django.shortcuts import render ... # 视图函数。 设置session def set_session(request): request.session['username'] = 'smart' # 设置sessio...

     

    应用名/views.py(视图,视图函数):

    from django.shortcuts import render
    from django.http import HttpResponse
    
    
    # 视图函数。 设置session
    def set_session(request):
        request.session['username'] = 'smart'  # 设置session
        request.session['age'] = 18
        # 设置过期时间(cookie中的session_id的过期时间)。 单位:秒
        request.session.set_expiry(5)  # 0:表示关闭浏览器过期;None:表示永不过期。 默认两周后过期。
        return HttpResponse('设置session')
    
    
    # 视图函数。 获取session
    def get_session(request):
        if request.session.has_key('username'):
            username = request.session['username']  # 获取session。 没有对应的值会抛异常。
        # request.session.get('键',默认值)    # 获取session
        return HttpResponse(username)
    
    
    # 视图函数。 清除session信息
    def clear_session(request):
        # request.session.clear()  # 清除session中的内容,但session_id对应的记录还存在。
        request.session.flush()  # 清除session中的内容,并且session_id对应的整条记录也被删除。
        # del request.session['键']   # 删除指定键和值。
        return HttpResponse('清除成功')
    
    

     


    项目名/settings.py(项目配置,开启session。默认已开启session):

     

    session的存储方式:数据库、缓存、混合存储。(默认存放在数据库的django_session表中)

    项目名/settings.py(项目配置,session的存储方式):

    # 存放在数据库中 (默认)
    SESSION_ENGINE='django.contrib.sessions.backends.db'
    
    # 存放在缓存中
    # SESSION_ENGINE='django.contrib.sessions.backends.cache'
    
    # 先从缓存中取,如果没有再从数据库中取。
    # SESSION_ENGINE='django.contrib.sessions.backends.cached_db'
    
    

    如果session存储在数据库中,需要在项INSTALLED_APPS中安装Session应用:

    项目名/settings.py(项目配置,INSTALLED_APPS中安装Session应用):

     


    使用Redis存储session

    1.安装redis

    pip3 install django-redis-sessions==0.5.6

    2. 项目名/settings.py(项目配置,增加如下配置):

    SESSION_ENGINE = 'redis_sessions.session'
    SESSION_REDIS_HOST = 'localhost'  # redis服务的ip
    SESSION_REDIS_PORT = 6379   # redis服务端口号
    SESSION_REDIS_DB = 2     # redis中的哪个数据库。 (redis中默认有16个数据库,数据库编号从0开始)
    SESSION_REDIS_PASSWORD = ''
    SESSION_REDIS_PREFIX = 'session'   # sessionid键的前缀。

    管理redis的命令,需要保证redis服务被开启

    查看:ps ajx|grep redis
    启动:sudo service redis start
    停止:sudo service redis stop
    使用客户端连接服务器:redis-cli
    切换数据库:select 2
    查看所有的键:keys *
    获取指定键的值:get name

    使用Redis存储session的第二种方式:

    安装Django-redis:  pip3 install django-redis

    项目名/settings.py(项目配置,设置Django的缓存):

    # Django的缓存配置 (用redis做缓存)
    CACHES = {
        "default": {
            "BACKEND": "django_redis.cache.RedisCache",
            "LOCATION": "redis://127.0.0.1:6379/9",
            "OPTIONS": {
                "CLIENT_CLASS": "django_redis.client.DefaultClient",
            }
        }
    }
    
    # 配置session存储 (用Django的默认缓存存储session)
    SESSION_ENGINE = "django.contrib.sessions.backends.cache"
    SESSION_CACHE_ALIAS = "default"
    
    

    应用名/views.py(视图,使用Django-redis操作redis):

    from django.http import HttpResponse
    from django.views import View
    # from redis import StrictRedis
    from django_redis import get_redis_connection
    
    # 类视图
    class MyView(View):
    
        def get(self, request):
            # from redis import StrictRedis  # 原生redis
            # sr = StrictRedis(host='172.0.0.1', port='6379', db=9)
    
            # 通过Django-redis获取StrictRedis对象。(需要在settings.py中配置redis的链接)
            con = get_redis_connection('default')  # con就是StrictRedis类型。default对应settings.py中CACHES中设置的default。
            result = con.set('name', '张三')   # redis中存储String
    
            return HttpResponse('ok')
    

    StrictRedis原生redis参考:https://blog.csdn.net/houyanhua1/article/details/85052846

     

    展开全文
  • python Django session/cookie

    2016-08-25 19:47:00
    一, Cookie #cookie # def cook1(request): # print(request.COOKIES) # 查看cooke # # print(request.get_signed_cookie('k2',salt='uuu')...# rep = HttpResponse('ok') # 设置cook 必须在响应里面设置 # ...
  • python requests库 Session 设置默认cookie

    千次阅读 2019-04-16 08:25:34
    r = requests.Session() for k, v in get_cookie().items(): r.cookies.set(k, v) 通过 r.cookies.set( ) 可以进行设置, 必须以键值对的形式进行
  • 按手册和网上的方法在settings.py中设置SESSION_COOKIE_AGE” 和 “SESSION_EXPIRE_AT_BROWSER_CLOSE” 均不生效。 通过查看django的源代码"middleware.py"才知道这两个参数只有在settings.SESSION_SAVE_EVERY_...
  • 我在使用django测试session和cookie的时候出现一个session无法设置的错误:  我建议你看下那个settings.py中有个MIDDLEWARE_CLASSES,你的有可能是MIDDLEWARE 你注意看一下   cookies测试 def set_cookies...
  • python中django框架中,设置session信息到redis中该如何配置 设置方法: 第一步: 打开项目中的sttings模块 第二步: 将下面代码放到settings中 # 缓存 CACHES = { # 必须有一项名为default "...
  • python - Flask session

    2019-10-26 15:33:45
    设置session在cookies里面的名字 设置session超时时间 读取,修改,清除 from flask import Flask, session app = Flask(__name__) app.secret_key = "xxxxxx" # session要用的秘钥 app.config['SESSI...
  • http协议本身是无状态的,为了让请求之间保持状态,有了session和cookie机制。requests也提供了相应的方法去操纵...# 第一步:发送一个请求,用于设置请求中的cookies # tips: http://httpbin.org能够用于测试http请求
  • python cookie和session

    2020-08-22 15:27:37
    用户登录, 未登录不能访问... # 设置cookie data = redirect('...') data.set_cookie() # 读取cookie request.COOKIES.get('xx') return data cookie的三个参数: key,value='',max_age=None 应用场景: 用户认证
  • 一.、配置 // 1. settings.py中的INSTALLED_APPS确保设置了 'django.contrib.sessions' // 2. settings.py中的MIDDLEWARE确保设置了 'django.contrib.sessions.... settings.py中新增使用缓存保存session...
  • Django session用到了settings中的这两个东西(默认django项目是已有的)。 然后需要执行数据迁移session才会有效,否则session就会报错的哦。 python manage.py makemigrations python manage.py ...
  • 最近开发一套接口,写个Python脚本,使用requests.session模拟一下登录. 因为每次需要获取用户信息,登录需要带着session信息,所以所有请求需要带着session。 请求使用post方式,请求参数类型为raw方式,参数为json...
  • Django项目默认启用Session。 可以在settings.py文件中查看 MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware...
  • Python web框架:Session

    2019-08-23 15:49:49
    除请求对象之外,还有一个 session 对象。它允许你在不同请求间存储特定用户的信息。...设置session[‘username’] = ‘xxx’ 删除:session.pop(‘username’, None) from flask import Flask,url_for,ses...
  • 1. 一次性的设置cookie 通过cookies参数传入的方式设置的cookie,不会被跨请求保持。 2. 可以跨请求的保持cookie的方法
  • python中requests.session的用法

    千次阅读 2019-10-14 23:39:19
    ###python中requests.session()的用法 session()中方法和requests()中一样 session.get() session.post() 用法:1 创建一个session对象 s = requests.Session() 用session对象发出get请求,设置cookies s.get(...
  • 当浏览器向服务器发送一个请求,被请求的接口可以设置cookie,通过Httpresponse对象的 set_cookie方法,添加 cookie 如 def login(request): Response=Httpresponse() Response.set_cookie['uname']=['liuchang'] ...
  • 什么是Session? cookie: 客户端浏览器的缓存; session: 服务端服务器的缓存; Session 和 Cookie类似,都是通过字典管理 key-value对。Session 对象存储特定用户会话所需的属性及配置信息。这样,当用户在应用程序...
  • 一些需要登录的网站,可以通过requests.session()来管理cookie,来实现会话...2、为 session 设置初始 cookie,可以通过 S.cookies = cookies 来设置,但是需要 cookjar 格式 # 自定义一个函数,用来将浏览器中的 co...
  • winreg.HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\Environment' 用户环境变量 HKEY_CURRENT_USER\Environment path_key = winreg.OpenKey(winreg.HKEY_LOCAL...
  • 0.概念 1.流程 第一次请求: ... ② 当我们的服务器接收到这个请求之后,进行用户名和密码的验证,验证没有问题可以设置session ... ③ 在设置session信息的同时(session信息保存在服务器端).服务器会在响应头中设置...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • 在进行接口测试的时候,我们会调用多个接口发出多个请求,在这些请求中有时候需要保持一些共用的数据,...# 用session对象发出get请求,设置cookies s.get('http://httpbin.org/cookies/set/sessioncookie/123456789')
  • Session ... 在服务器端进行状态保持的方案就是Session。 ...数据迁移后会在数据库中创建出存储Session的表。...python manage.py migrate 数据库就默认就有一个名字为 django_session 来保存se...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 417
精华内容 166
关键字:

python设置session

python 订阅