stringa = 'purple alice@google.com, blah monkey bob@abcdef.com blah dishwasher'

###### re.sub(pat, replacement, str) -- returns new string with all replacements,

###### \1 is group(1), \2 group(2) in the replacement

newHostString=re.sub(r'([\w\.-]+)@([\w\.-]+)', r'\1@yo-yoe.com', stringa)

print ""

print "input:{}".format(stringa)

tag_string= "<b>foo</b> and <i>so on</i>"

ex_greedy_search=copy.deepcopy(tag_string)

ex_non_greedy_search="<b>"

act_greedy=re.search(r'(<.*>)',tag_string).group()

act_non_greedy=re.search(r'(<.*?>)', tag_string).group()

print ""

print "ag:{} ang:{}".format(act_greedy, act_non_greedy)

print "eg:{} eng:{}".format(ex_greedy_search, ex_non_greedy_search)

assert(act_greedy == ex_greedy_search )

rex=r'\b'+strings+r'\b'

print "rex={0}".format(rex)

pattern=re.compile(rex)

max_in_one_line=0

max_line_number=0

total_found=0

with open(filename) as lines:

for i,line in enumerate(lines):

lista=pattern.findall(line)

current=len(lista)

print "current={0} found={1} ".format(current,lista)

if (current>max_in_one_line):

max_in_one_line=current

max_line_number=i;

total_found=total_found+current

tag_string= "<b>foo</b> and <i>so on</i>"

ex_greedy_search=copy.deepcopy(tag_string)

ex_non_greedy_search="<b>"

act_greedy=re.search(r'(<.*>)',tag_string).group()

act_non_greedy=re.search(r'(<.*?>)', tag_string).group()

print ""

print "ag:{} ang:{}".format(act_greedy, act_non_greedy)

print "eg:{} eng:{}".format(ex_greedy_search, ex_non_greedy_search)

assert(act_greedy == ex_greedy_search )

wordlist = ['mississippi', 'miss', 'lake', 'que']

letters = set('aqk')

list = [word for word in wordlist if (letters & set(word))]

with open(oldfile, 'r', encoding='utf-8') as infile, open(newfile, 'w') as outfile:

for line in infile:

if line.startswith(txt):

line = line[0:len(txt)] + ' - Truly a great person!\n'

bad_filenames = {}

for one_filename in all_filenames:

try:

process_txt_file("searched line",one_filename,one_filename+"out")

except fatal_exceptions:

print 'error'

raise

except Exception:

f = cStringIO.StringIO()

traceback.print_exc(file=f)

bad_filenames[one_filename] = f.getvalue()

filenames=["non_existing_file1" , "non_existing_file2"]

ret=process_all_files_trap_exceptions(filenames)

print ret.keys()

try:

print d['key']

except KeyError:

dict={}

addword(dict,"guliver",78)

addword(dict,"guliver",169)

addword(dict,"liliput",9)

addword(dict,"liliput",19)

dict={}

dictInc(dict,"guliver")

dictInc(dict,"guliver")

dictInc(dict,"liliput")

dictInc(dict,"liliput")

seq = [2012, "obama", 2008, "boosh", 1996, "clinton", 1972, "nixon"]

dict=dictFromSequenceXY(seq)

subdict=sub_dict(dict,[1972,2008,2012])

seq = [2012, "obama", 2008, "boosh", 1996, "clinton", 1972 ,"nixon"]

dict=dictFromSequenceXY(seq)

subdict=sub_dict_remove(dict,[1996,2008])

seq = [2012, "obama", 2008, "boosh", 1996, "clinton"]

dict=dictFromSequenceXY(seq)

inverted_dict=invert_large_dict_fast(dict)

animals = [ ]

number_of_felines = 0

def deal_with_a_cat( ):

global number_of_felines

print "meow"

animals.append('feline')

number_of_felines += 1

def deal_with_a_dog( ):

print "bark"

animals.append('canine')

def deal_with_a_bear( ):

print "watch out for the *HUG*!"

animals.append('ursine')

tokenDict = {

"cat": deal_with_a_cat,

"dog": deal_with_a_dog,

"bear": deal_with_a_bear,

}

# Simulate, say, some words read from a file

words = ["cat", "bear", "cat", "dog"]

for word in words:

# Look up the function to call for each word, and call it

print tokenDict[word]( )

nf = number_of_felines

print 'we met %d feline%s' % (nf, 's'[nf==1:])

if len(dicta) < len(dictb):

inter = dict.fromkeys([x for x in dicta if x not in dictb])

else:

seq = {2012, "obama", 2008, "boosh", 1996, "clinton"}

dict = dictFromSequenceXY(seq)

subdict = sub_dict_remove(dict, [1996])

subdict[1972]="nixon"

seqa = {1960,"kenedy",1996, "clinton", 2008, "boosh", 2012, "obama"}

seqb= {1940,"democrats",1972,"republicans", 2008, "republicans", 2012, "democrats"}

dicta = dictFromSequenceXY(seqa)

dictb = dictFromSequenceXY(seqb)

#TODO

#assert(False)

#probability

x = random.uniform(0, 1)

cumulative_probability = 0.0

for item, item_probability in zip(some_list, probabilities):

cumulative_probability += item_probability

if x < cumulative_probability:

break

lista=list()

for i in range (0,10):

lista.append(random_pick([1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,10],

[0.05,0.02,0.03,0.15,0.35,0.01,0.01,0.18,0.1,0.1]))

x = random_picks_weight('ciao', [1, 1, 3, 2])

list_two_chars=list()

for two_chars in zip('boo', x):

list_two_chars.append(''.join(two_chars))

print list_two_chars

nested = [[1, 2], [3, 4], [5]]

flatten(nested)

for num in flatten(nested):

def __init__(self):

self.q = [ ]

self.i = 0

def push(self, item, cost):

heapq.heappush(self.q, (-cost, self.i, item))

self.i += 1

def pop(self):

data = {12:'twelve', 'feep':list('ciao'), 1.23:4+5j, (1,2,3):u'wer'}

bytes = marshal.dumps(data)

text = cPickle.dumps(data)

#or to a binary string, a choice that is faster and takes up less space:

bytes = cPickle.dumps(data, 2)

#You can now sling text or bytes around as you wish (e.g., send across a network, include as a

#BLOB in a databasesee Recipe 7.10, Recipe 7.11, and Recipe 7.12) as long as you keep text or

#bytes intact. In the case of bytes, it means keeping the arbitrary binary bytes intact. In the case

#of text, it means keeping its textual structure intact, including newline characters. Then you can

#reconstruct the data at any time, regardless of machine architecture or Python release:

readata1 = cPickle.loads(text)

readata2 = cPickle.loads(bytes)

print readata1

''' save objects into a compressed diskfile '''

fil = gzip.open(filename, 'wb')

for obj in objects: cPickle.dump(obj, fil, proto=2)

''' reload objects from a compressed diskfile '''

fil = gzip.open(filename, 'rb')

while True:

try: yield cPickle.load(fil)

except EOFError: break

""" Given a DB API 2.0 cursor object that has been executed, returns

results = { }

for column, desc in enumerate(cursor.description):

results[desc[0]] = column

if not data:

data = cursor.fetchall( )

names = [ ]

lengths = [ ]

rules = [ ]

for col, field_description in enumerate(cursor.description):

field_name = field_description[0]

names.append(field_name)

field_length = field_description[2] or 12

field_length = max(field_length, len(field_name))

if check_row_lengths:

# double-check field length, if it's unreliable

data_length = max([ len(str(row[col])) for row in data ])

field_length = max(field_length, data_length)

lengths.append(field_length)

rules.append('-' * field_length)

format = " ".join(["%%-%ss" % l for l in lengths])

result = [ format % tuple(names), format % tuple(rules) ]

for row in data:

result.append(format % tuple(row))

#prety_print_database(cursor, data, False)

#raise

#TODO

if __debug__:

stack = traceback.extract_stack( )[-2:][0]

actualCall = stack[3]

if actualCall is None:

actualCall = "watch([unknown])"

left = actualCall.find('(')

right = actualCall.rfind(')')

paramDict = {} # dict(varName=actualCall[left+1:right]).strip( ),varType=str(type(variableName))[7:-2],value=repr(variableName),methodName=stack[2],lineNumber=stack[1],fileName=stack[0])

watchOutput.write(watch_format % paramDict)

# calling 'trace("this line was executed")' prints out something like:

# File "trace.py", line 64, in ?

# this line was executed

trace_format = ('File "%(fileName)s", line %(lineNumber)d, in'

if __debug__:

stack = traceback.extract_stack( )[-2:][0]

paramDict = dict(text=text,

methodName=stack[2],

lineNumber=stack[1],

fileName=stack[0])