Python Interview Questions And Answers Set - 8
How to use Sessions for Web python ?
Sessions are the server side version of cookies. While a cookie persists data (or state) at the client, sessions do it at the server. Sessions have the advantage that the data do not travel the network thus making it both safer and faster although this not entirely true as shown in the next paragraph
The session state is kept in a file or in a database at the server side. Each session is identified by an id or session id (SID). To make it possible to the client to identify himself to the server the SID must be created by the server and sent to the client and then sent back to the server whenever the client makes a request. There is still data going through the net, the SID.
The server can send the SID to the client in a link's query string or in a hidden form field or as a Set-Cookie header. The SID can be sent back from the client to the server as a query string parameter or in the body of the HTTP message if the post method is used or in a Cookie HTTP header.
If a cookie is not used to store the SID then the session will only last until the browser is closed, or the user goes to another site breaking the POST or query string transmission, or in other words, the session will last only until the user leaves the site.
* Cookie Based SID:
A cookie based session has the advantage that it lasts until the cookie expires and, as only the SID travels the net, it is faster and safer. The disadvantage is that the client must have cookies enabled.
The only particularity with the cookie used to set a session is its value:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
The hash of the server time makes an unique SID for each session.
#!/usr/bin/env python
import sha, time, Cookie, os
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
# If new session
if not string_cookie:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
# Set the sid in the cookie
cookie['sid'] = sid
# Will expire in a year
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# If already existent session
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
print cookie
print 'Content-Type: text/html\n'
print ''
if string_cookie:
print '
else:
print '
print '
print ''
In every page the existence of the cookie must be tested. If it does not exist then redirect to a login page or just create it if a login or a previous state is not required.
* Query String SID;
Query string based session:
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
""" % (message, sid, sid)
To mantain a session you will have to append the query string to all the links in the page.
Save this file as set_sid_qs.py and run it two or more times. Try to close the browser and call the page again. The session is gone. The same happens if the page address is typed in the address bar.
* Hidden Field SID;
The hidden form field SID is almost the same as the query string based one, sharing the same problems.
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
""" % (message, sid, sid)
* The shelve module;
Having a SID is not enough. It is necessary to save the session state in a file or in a database. To save it into a file the shelve module is used. The shelve module opens a file and returns a dictionary like object which is readable and writable as a dictionary.
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
The SID is part of file name making it a unique file. The apache user must have read and write permission on the file's directory. 660 would be ok.
The values of the dictionary can be any Python object. The keys must be immutable objects.
# Save the current time in the session
session['lastvisit'] = repr(time.time())
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
The dictionary like object must be closed as any other file should be:
session.close()
* Cookie and Shelve;
A sample of how to make cookies and shelve work together keeping session state at the server side:
#!/usr/bin/env python
import sha, time, Cookie, os, shelve
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
if not string_cookie:
sid = sha.new(repr(time.time())).hexdigest()
cookie['sid'] = sid
message = 'New session'
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
if lastvisit:
message = 'Welcome back. Your last visit was at ' + \
time.asctime(time.gmtime(float(lastvisit)))
# Save the current time in the session
session['lastvisit'] = repr(time.time())
print """\
%s
Content-Type: text/html\n
""" % (cookie, message, sid)
session.close()
It first checks if there is a cookie already set. If not it creates a SID and attributes it to the cookie value. An expiration time of one year is established.
The lastvisit data is what is maintained in the session.
How to use Sessions for Web python ?
Sessions are the server side version of cookies. While a cookie persists data (or state) at the client, sessions do it at the server. Sessions have the advantage that the data do not travel the network thus making it both safer and faster although this not entirely true as shown in the next paragraph
The session state is kept in a file or in a database at the server side. Each session is identified by an id or session id (SID). To make it possible to the client to identify himself to the server the SID must be created by the server and sent to the client and then sent back to the server whenever the client makes a request. There is still data going through the net, the SID.
The server can send the SID to the client in a link's query string or in a hidden form field or as a Set-Cookie header. The SID can be sent back from the client to the server as a query string parameter or in the body of the HTTP message if the post method is used or in a Cookie HTTP header.
If a cookie is not used to store the SID then the session will only last until the browser is closed, or the user goes to another site breaking the POST or query string transmission, or in other words, the session will last only until the user leaves the site.
* Cookie Based SID:
A cookie based session has the advantage that it lasts until the cookie expires and, as only the SID travels the net, it is faster and safer. The disadvantage is that the client must have cookies enabled.
The only particularity with the cookie used to set a session is its value:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
The hash of the server time makes an unique SID for each session.
#!/usr/bin/env python
import sha, time, Cookie, os
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
# If new session
if not string_cookie:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
# Set the sid in the cookie
cookie['sid'] = sid
# Will expire in a year
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# If already existent session
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
print cookie
print 'Content-Type: text/html\n'
print ''
if string_cookie:
print '
else:
print '
print '
print ''
In every page the existence of the cookie must be tested. If it does not exist then redirect to a login page or just create it if a login or a previous state is not required.
* Query String SID;
Query string based session:
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
""" % (message, sid, sid)
To mantain a session you will have to append the query string to all the links in the page.
Save this file as set_sid_qs.py and run it two or more times. Try to close the browser and call the page again. The session is gone. The same happens if the page address is typed in the address bar.
* Hidden Field SID;
The hidden form field SID is almost the same as the query string based one, sharing the same problems.
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
""" % (message, sid, sid)
* The shelve module;
Having a SID is not enough. It is necessary to save the session state in a file or in a database. To save it into a file the shelve module is used. The shelve module opens a file and returns a dictionary like object which is readable and writable as a dictionary.
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
The SID is part of file name making it a unique file. The apache user must have read and write permission on the file's directory. 660 would be ok.
The values of the dictionary can be any Python object. The keys must be immutable objects.
# Save the current time in the session
session['lastvisit'] = repr(time.time())
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
The dictionary like object must be closed as any other file should be:
session.close()
* Cookie and Shelve;
A sample of how to make cookies and shelve work together keeping session state at the server side:
#!/usr/bin/env python
import sha, time, Cookie, os, shelve
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
if not string_cookie:
sid = sha.new(repr(time.time())).hexdigest()
cookie['sid'] = sid
message = 'New session'
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
if lastvisit:
message = 'Welcome back. Your last visit was at ' + \
time.asctime(time.gmtime(float(lastvisit)))
# Save the current time in the session
session['lastvisit'] = repr(time.time())
print """\
%s
Content-Type: text/html\n
""" % (cookie, message, sid)
session.close()
It first checks if there is a cookie already set. If not it creates a SID and attributes it to the cookie value. An expiration time of one year is established.
The lastvisit data is what is maintained in the session.
Sessions are the server side version of cookies. While a cookie persists data (or state) at the client, sessions do it at the server. Sessions have the advantage that the data do not travel the network thus making it both safer and faster although this not entirely true as shown in the next paragraph
The session state is kept in a file or in a database at the server side. Each session is identified by an id or session id (SID). To make it possible to the client to identify himself to the server the SID must be created by the server and sent to the client and then sent back to the server whenever the client makes a request. There is still data going through the net, the SID.
The server can send the SID to the client in a link's query string or in a hidden form field or as a Set-Cookie header. The SID can be sent back from the client to the server as a query string parameter or in the body of the HTTP message if the post method is used or in a Cookie HTTP header.
If a cookie is not used to store the SID then the session will only last until the browser is closed, or the user goes to another site breaking the POST or query string transmission, or in other words, the session will last only until the user leaves the site.
* Cookie Based SID:
A cookie based session has the advantage that it lasts until the cookie expires and, as only the SID travels the net, it is faster and safer. The disadvantage is that the client must have cookies enabled.
The only particularity with the cookie used to set a session is its value:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
The hash of the server time makes an unique SID for each session.
#!/usr/bin/env python
import sha, time, Cookie, os
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
# If new session
if not string_cookie:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
# Set the sid in the cookie
cookie['sid'] = sid
# Will expire in a year
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# If already existent session
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
print cookie
print 'Content-Type: text/html\n'
print ''
if string_cookie:
print '
Already existent session
'else:
print '
New session
'print '
SID =', sid, '
'print ''
In every page the existence of the cookie must be tested. If it does not exist then redirect to a login page or just create it if a login or a previous state is not required.
* Query String SID;
Query string based session:
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
%s
SID = %s
""" % (message, sid, sid)
To mantain a session you will have to append the query string to all the links in the page.
Save this file as set_sid_qs.py and run it two or more times. Try to close the browser and call the page again. The session is gone. The same happens if the page address is typed in the address bar.
* Hidden Field SID;
The hidden form field SID is almost the same as the query string based one, sharing the same problems.
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
%s
SID = %s
""" % (message, sid, sid)
* The shelve module;
Having a SID is not enough. It is necessary to save the session state in a file or in a database. To save it into a file the shelve module is used. The shelve module opens a file and returns a dictionary like object which is readable and writable as a dictionary.
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
The SID is part of file name making it a unique file. The apache user must have read and write permission on the file's directory. 660 would be ok.
The values of the dictionary can be any Python object. The keys must be immutable objects.
# Save the current time in the session
session['lastvisit'] = repr(time.time())
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
The dictionary like object must be closed as any other file should be:
session.close()
* Cookie and Shelve;
A sample of how to make cookies and shelve work together keeping session state at the server side:
#!/usr/bin/env python
import sha, time, Cookie, os, shelve
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
if not string_cookie:
sid = sha.new(repr(time.time())).hexdigest()
cookie['sid'] = sid
message = 'New session'
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
if lastvisit:
message = 'Welcome back. Your last visit was at ' + \
time.asctime(time.gmtime(float(lastvisit)))
# Save the current time in the session
session['lastvisit'] = repr(time.time())
print """\
%s
Content-Type: text/html\n
%s
SID = %s
""" % (cookie, message, sid)
session.close()
It first checks if there is a cookie already set. If not it creates a SID and attributes it to the cookie value. An expiration time of one year is established.
The lastvisit data is what is maintained in the session.
How to use Sessions for Web python ?
Sessions are the server side version of cookies. While a cookie persists data (or state) at the client, sessions do it at the server. Sessions have the advantage that the data do not travel the network thus making it both safer and faster although this not entirely true as shown in the next paragraph
The session state is kept in a file or in a database at the server side. Each session is identified by an id or session id (SID). To make it possible to the client to identify himself to the server the SID must be created by the server and sent to the client and then sent back to the server whenever the client makes a request. There is still data going through the net, the SID.
The server can send the SID to the client in a link's query string or in a hidden form field or as a Set-Cookie header. The SID can be sent back from the client to the server as a query string parameter or in the body of the HTTP message if the post method is used or in a Cookie HTTP header.
If a cookie is not used to store the SID then the session will only last until the browser is closed, or the user goes to another site breaking the POST or query string transmission, or in other words, the session will last only until the user leaves the site.
* Cookie Based SID:
A cookie based session has the advantage that it lasts until the cookie expires and, as only the SID travels the net, it is faster and safer. The disadvantage is that the client must have cookies enabled.
The only particularity with the cookie used to set a session is its value:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
The hash of the server time makes an unique SID for each session.
#!/usr/bin/env python
import sha, time, Cookie, os
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
# If new session
if not string_cookie:
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
# Set the sid in the cookie
cookie['sid'] = sid
# Will expire in a year
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# If already existent session
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
print cookie
print 'Content-Type: text/html\n'
print ''
if string_cookie:
print '
Already existent session
'else:
print '
New session
'print '
SID =', sid, '
'print ''
In every page the existence of the cookie must be tested. If it does not exist then redirect to a login page or just create it if a login or a previous state is not required.
* Query String SID;
Query string based session:
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
%s
SID = %s
""" % (message, sid, sid)
To mantain a session you will have to append the query string to all the links in the page.
Save this file as set_sid_qs.py and run it two or more times. Try to close the browser and call the page again. The session is gone. The same happens if the page address is typed in the address bar.
* Hidden Field SID;
The hidden form field SID is almost the same as the query string based one, sharing the same problems.
#!/usr/bin/env python
import sha, time, cgi, os
sid = cgi.FieldStorage().getfirst('sid')
if sid: # If session exists
message = 'Already existent session'
else: # New session
# The sid will be a hash of the server time
sid = sha.new(repr(time.time())).hexdigest()
message = 'New session'
qs = 'sid=' + sid
print """\
Content-Type: text/html\n
%s
SID = %s
""" % (message, sid, sid)
* The shelve module;
Having a SID is not enough. It is necessary to save the session state in a file or in a database. To save it into a file the shelve module is used. The shelve module opens a file and returns a dictionary like object which is readable and writable as a dictionary.
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
The SID is part of file name making it a unique file. The apache user must have read and write permission on the file's directory. 660 would be ok.
The values of the dictionary can be any Python object. The keys must be immutable objects.
# Save the current time in the session
session['lastvisit'] = repr(time.time())
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
The dictionary like object must be closed as any other file should be:
session.close()
* Cookie and Shelve;
A sample of how to make cookies and shelve work together keeping session state at the server side:
#!/usr/bin/env python
import sha, time, Cookie, os, shelve
cookie = Cookie.SimpleCookie()
string_cookie = os.environ.get('HTTP_COOKIE')
if not string_cookie:
sid = sha.new(repr(time.time())).hexdigest()
cookie['sid'] = sid
message = 'New session'
else:
cookie.load(string_cookie)
sid = cookie['sid'].value
cookie['sid']['expires'] = 12 * 30 * 24 * 60 * 60
# The shelve module will persist the session data
# and expose it as a dictionary
session = shelve.open('/tmp/.session/sess_' + sid, writeback=True)
# Retrieve last visit time from the session
lastvisit = session.get('lastvisit')
if lastvisit:
message = 'Welcome back. Your last visit was at ' + \
time.asctime(time.gmtime(float(lastvisit)))
# Save the current time in the session
session['lastvisit'] = repr(time.time())
print """\
%s
Content-Type: text/html\n
%s
SID = %s
""" % (cookie, message, sid)
session.close()
It first checks if there is a cookie already set. If not it creates a SID and attributes it to the cookie value. An expiration time of one year is established.
The lastvisit data is what is maintained in the session.