import uuid

def generate_activation_code(count):

code_list = []

for i in xrange(count):

code = str(uuid.uuid4()).replace('-', '').upper()

if not code in code_list:

code_list.append(code)

return code_list

if __name__ == "__main__":

code_list = generate_activation_code(200)

for code in code_list:

print code

import uuid

import MySQLdb

class ActivationCode(object):

def __init__(self, code_count, database, username, host='localhost', port=3306, password=''):

self._host = host

self._username = username

self._password = password

self._database = database

self._port = port

self.codes = self._generate_activation_code(code_count)

#print self.codes

def _get_mysql_instance(self):

params = {

'host': self._host,

'user': self._username,

'passwd': self._password,

'db': self._database,

'port': self._port,

}

return MySQLdb.connect(**params)

def _generate_activation_code(self, count):

code_list = []

for i in xrange(count):

code = str(uuid.uuid4()).replace('-', '').upper()

if not code in code_list:

code_list.append(code)

return code_list

def store_to_mysql(self):

if self.codes:

conn = self._get_mysql_instance()

try:

cur = conn.cursor()

# clear old datas

cur.execute('delete from code')

# insert mutilple code

for code in self.codes:

cur.execute("insert into code(code) values('%s')" % code)

conn.commit()

cur.close()

conn.close()

return True

except MySQLdb.Error,e:

conn.rollback()

print "Mysql Error %d: %s" % (e.args[0], e.args[1])

return False

def print_activation_code(self):

conn = self._get_mysql_instance()

try:

cur = conn.cursor()

cur.execute('select code from code')

results = cur.fetchall()

for row in results:

print row[0]

except MySQLdb.Error,e:

print "Mysql Error %d: %s" % (e.args[0], e.args[1])

if __name__ == "__main__":

active_code = ActivationCode(200, database='Test', username='root')

if active_code.store_to_mysql():

active_code.print_activation_code()

import uuid

import redis

def get_redis_instance(host='localhost', port=6379):

return redis.StrictRedis(host=host, port=port)

def generate_activation_code(count):

code_list = []

for i in xrange(count):

code = str(uuid.uuid4()).replace('-', '').upper()

if not code in code_list:

code_list.append(code)

return code_list

def store_to_redise(codes):

if codes:

cache = get_redis_instance()

try:

cache.set('code:count', len(codes))

for i in xrange(len(codes)):

cache.set('code:{0}'.format(i), codes[i])

cache.save()

return True

except:

print 'Can not connect to redis server !!!'

return False

def print_activation_code():

cache = get_redis_instance()

try:

count = cache.get('code:count')

count = 0 if count is None else int(count)

for i in xrange(count):

print cache.get('code:%d'%i)

except:

print 'Can not connect to redis server !!!'

if __name__ == "__main__":

code_list = generate_activation_code(200)

if store_to_redise(code_list):

print_activation_code()

import collections

import re

def count_word(file_name):

f = open(file_name)

line = f.readline()

word_counter = collections.Counter()

while line:

words = re.findall("\w+", line.lower())

word_counter.update(words)

line = f.readline()

f.close()

return word_counter

if __name__ == '__main__':

print count_word('english.txt')

In English, that means start with any non-'defaults' keyword argument that doesn’t contain a double underscore (which would indicate a non-exact lookup). Then add the contents of defaults, overriding any keys if necessary, and use the result as the keyword arguments to the model class. As hinted at above, this is a simplification of the algorithm that is used, but it contains all the pertinent details. The internal implementation has some more error-checking than this and handles some extra edge-conditions; if you’re interested, read the code.

If you have a field named defaults and want to use it as an exact lookup in get_or_create(), just use 'defaults__exact', like so:

The get_or_create() method has similar error behavior to create() when you’re using manually specified primary keys. If an object needs to be created and the key already exists in the database, an IntegrityError will be raised.

This method is atomic assuming correct usage, correct database configuration, and correct behavior of the underlying database. However, if uniqueness is not enforced at the database level for the kwargs used in a get_or_create call (see unique or unique_together), this method is prone to a race-condition which can result in multiple rows with the same parameters being inserted simultaneously.

If you are using MySQL, be sure to use the READ COMMITTED isolation level rather than REPEATABLE READ (the default), otherwise you may see cases where get_or_create will raise an IntegrityError but the object won’t appear in a subsequent get() call.

Finally, a word on using get_or_create() in Django views. Please make sure to use it only in POST requests unless you have a good reason not to. GET requests shouldn’t have any effect on data. Instead, use POST whenever a request to a page has a side effect on your data. For more, see Safe methods in the HTTP spec.