Search is not available for this dataset
text
stringlengths 75
104k
|
|---|
def insert_some(ol,*eles,**kwargs):
'''
from elist.elist import *
ol = [1,2,3,4]
id(ol)
insert_some(ol,5,6,7,8,index=2,mode="original")
ol
id(ol)
####
ol = [1,2,3,4]
id(ol)
new = insert_some(ol,5,6,7,8,index=2)
new
id(new)
'''
start_index = kwargs['index']
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
length = ol.__len__()
cpol = copy.deepcopy(ol)
if(mode == "new"):
si = uniform_index(start_index,length)
new = copy.deepcopy(cpol[0:si])
new.extend(list(eles))
new.extend(cpol[si:])
return(new)
else:
si = uniform_index(start_index,length)
new = cpol[0:si]
new.extend(list(eles))
new.extend(cpol[si:])
ol.clear()
for i in range(0,new.__len__()):
ol.append(new[i])
return(ol) |
def insert_many(ol,eles,locs,**kwargs):
'''
from elist.elist import *
ol = [1,2,3,4,5]
eles = [7,77,777]
locs = [0,2,4]
id(ol)
new = insert_many(ol,eles,locs)
ol
new
id(new)
####
ol = [1,2,3,4,5]
eles = [7,77,777]
locs = [0,2,4]
id(ol)
rslt = insert_many(ol,eles,locs,mode="original")
ol
rslt
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
eles = copy.deepcopy(eles)
locs = copy.deepcopy(locs)
new = []
length = ol.__len__()
cpol = copy.deepcopy(ol)
for i in range(0,locs.__len__()):
if(locs[i]>=length):
pass
else:
locs[i] = uniform_index(locs[i],length)
tmp = sorted_refer_to(eles,locs)
eles = tmp['list']
locs = tmp['referer']
label = eles.__len__()
si = 0
ei = 0
for i in range(0,locs.__len__()):
if(locs[i]>=length):
label = i
break
else:
ei = locs[i]
new.extend(cpol[si:ei])
new.append(eles[i])
si = ei
for i in range(label,locs.__len__()):
new.append(eles[i])
new.extend(cpol[ei:])
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def insert_sections_some(ol,*secs,**kwargs):
'''
ol = initRange(0,20,1)
ol
loc = 6
rslt = insert_sections_some(ol,['a','a','a'],['c','c','c','c'],index=loc)
rslt
####
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
loc = kwargs['index']
secs = list(secs)
secs = [concat(*secs)]
locs = [loc]
return(insert_sections_many(ol,secs,locs,mode=mode)) |
def insert_section(ol,sec,loc,**kwargs):
'''
ol = initRange(0,20,1)
ol
loc = 6
sec = ['a','b','c','d']
rslt = insert_section(ol,sec,loc)
rslt
####
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
secs = [sec]
locs = [loc]
return(insert_sections_many(ol,secs,locs,mode=mode)) |
def insert_sections_many(ol,secs,locs,**kwargs):
'''
ol = initRange(0,20,1)
ol
locs = [1,6,14,9]
secs = [
['a','a','a'],
['b','b'],
['c','c','c','c'],
['d','d']
]
rslt = insert_sections_many(ol,secs,locs)
rslt
####
ol
locs = [0,3,6,9,12,15,16]
secs = [
['a','a','a'],
['b','b'],
['c','c','c','c'],
['d','d']
]
rslt = insert_sections_many(ol,secs,locs)
rslt
####
ol
locs = [1,6,14,9]
secs = [
['a','a','a'],
['b','b'],
['c','c','c','c'],
['d','d'],
['e'],
['f','f','f','f'],
[777,777,777,777]
]
rslt = insert_sections_many(ol,secs,locs)
rslt
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
secs = copy.deepcopy(secs)
locs = copy.deepcopy(locs)
brked = broken_seqs(ol,locs)
seclen = secs.__len__()
brklen = brked.__len__()
if(locs[0]==0):
new = secs[0]
length = seclen -1
if(length < brklen):
for i in range(0,length):
new.extend(brked[i])
new.extend(secs[i+1])
for i in range(length,brklen):
new.extend(brked[i])
elif(length == brklen):
for i in range(0,length):
new.extend(brked[i])
new.extend(secs[i+1])
else:
for i in range(0,brklen):
new.extend(brked[i])
new.extend(secs[i+1])
for i in range(brklen,length):
new.extend(secs[i])
else:
new = brked[0]
length = brklen -1
if(length < seclen):
for i in range(0,length):
new.extend(secs[i])
new.extend(brked[i+1])
for i in range(length,seclen):
new.extend(secs[i])
elif(length == seclen):
for i in range(0,length):
new.extend(secs[i])
new.extend(brked[i+1])
else:
for i in range(0,seclen):
new.extend(secs[i])
new.extend(brked[i+1])
for i in range(seclen,length):
new.extend(brked[i])
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def reorder_sub(ol,sub):
'''
sub = ['query', 'params', 'fragment', 'path']
ol = ['scheme', 'username', 'password', 'hostname', 'port', 'path', 'params', 'query', 'fragment']
reorder_sub(ol,sub)
'''
def cond_func(ele,ol):
index = ol.index(ele)
return(index)
indexes = array_map(sub,cond_func,ol)
nsub = sorted_refer_to(sub,indexes)['list']
return(nsub) |
def sort(ol,**kwargs):
'''
from elist.elist import *
ol = [1,3,4,2]
id(ol)
new = sort(ol)
ol
new
id(ol)
id(new)
####
ol = [1,3,4,2]
id(ol)
rslt = sort(ol,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
new = copy.deepcopy(ol)
new.sort()
return(new)
else:
ol.sort()
return(ol) |
def sorted_refer_to(l,referer,reverse=False,**kwargs):
'''
from elist.elist import *
l = ["a","b","c"]
referer = [7,8,6]
sorted_refer_to(l,referer)
{'list': ['c', 'a', 'b'], 'referer': [6, 7, 8]}
l
referer
>>>
'''
if("mode" in kwargs):
mode = kwargs["mode"]
else:
mode = "both"
tl =[]
length = l.__len__()
for i in range(0,length):
ele = (l[i],referer[i])
tl.append(ele)
tl = sorted(tl,key=itemgetter(1),reverse=reverse)
sorted_l =[]
sorted_r = []
for i in range(0,length):
sorted_l.append(tl[i][0])
sorted_r.append(tl[i][1])
if(mode == "only-list"):
return(sorted_l)
elif(mode == "only-referer"):
return(referer)
else:
return({"list":sorted_l,"referer":sorted_r}) |
def batsorted(referer,*lists,**kwargs):
'''
from elist.elist import *
referer = [4,2,3,1]
l1 = ['a','b','c','d']
l2 = [100,200,300,400]
l3 = ['A','B','A','B']
nl1,nl2,nl3 = batsorted(referer,l1,l2,l3)
nl1
nl2
nl3
nl1,nl2,nl3 = batsorted(referer,l1,l2,l3,reverse=True)
nl1
nl2
nl3
####the batsorted will not modify the original lists
l1
l2
l3
'''
if('reverse' in kwargs):
reverse = kwargs['reverse']
else:
reverse = False
length = referer.__len__()
indexes = list(range(0,length))
rslt = sorted_refer_to(indexes,referer,reverse=reverse)
referer = rslt['referer']
indexes = rslt['list']
rslt = []
lists = copy.deepcopy(list(lists))
for i in range(0,lists.__len__()):
l = lists[i]
nl = []
for j in range(0,length):
loc = indexes[j]
nl.append(l[loc])
rslt.append(nl)
return(tuple(rslt)) |
def sortDictList(dictList,**kwargs):
'''
students = [
{'name':'john','class':'A', 'year':15},
{'name':'jane','class':'B', 'year':12},
{'name':'dave','class':'B', 'year':10}
]
rslt = sortDictList(students,cond_keys=['name','class','year'])
pobj(rslt)
rslt = sortDictList(students,cond_keys=['name','year','class'])
pobj(rslt)
rslt = sortDictList(students,cond_keys=['class','name','year'])
pobj(rslt)
rslt = sortDictList(students,cond_keys=['class','year','name'])
pobj(rslt)
rslt = sortDictList(students,cond_keys=['year','name','class'])
pobj(rslt)
rslt = sortDictList(students,cond_keys=['year','name','class'])
pobj(rslt)
'''
def default_eq_func(value1,value2):
cond = (value1 == value2)
return(cond)
def default_gt_func(value1,value2):
cond = (value1 > value2)
return(cond)
def default_lt_func(value1,value2):
cond = (value1 < value2)
return(cond)
if('eq_func' in kwargs):
eq_func = kwargs['eq_func']
else:
eq_func = default_eq_func
if('gt_func' in kwargs):
gt_func = kwargs['gt_func']
else:
gt_func = default_gt_func
if('lt_func' in kwargs):
lt_func = kwargs['lt_func']
else:
lt_func = default_lt_func
if('reverse' in kwargs):
reverse = kwargs['reverse']
else:
reverse = False
keys = kwargs['cond_keys']
def cmp_dict(d1,d2):
'''
'''
length = keys.__len__()
for i in range(0,length):
key = keys[i]
cond = eq_func(d1[key],d2[key])
if(cond):
pass
else:
cond = gt_func(d1[key],d2[key])
if(cond):
return(1)
else:
return(-1)
return(0)
ndl = dictList
ndl = sorted(ndl,key=functools.cmp_to_key(cmp_dict),reverse=reverse)
return(ndl) |
def index_firstnot(ol,value):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
index_firstnot(ol,'a')
####index_firstnot, array_indexnot, indexOfnot are the same
array_indexnot(ol,'a')
indexOfnot(ol,'a')
'''
length = ol.__len__()
for i in range(0,length):
if(value == ol[i]):
pass
else:
return(i)
return(None) |
def index_last(ol,value):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
index_last(ol,'a')
####lastIndexOf is the same as index_last
lastIndexOf(ol,'a')
'''
length = ol.__len__()
for i in range(length-1,-1,-1):
if(value == ol[i]):
return(i)
else:
pass
return(None) |
def index_lastnot(ol,value):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
index_lastnot(ol,'a')
####lastIndexOfnot is the same as index_lastnot
lastIndexOfnot(ol,'a')
'''
length = ol.__len__()
for i in range(length-1,-1,-1):
if(value == ol[i]):
pass
else:
return(i)
return(None) |
def index_whichnot(ol,value,which):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
index_whichnot(ol,'a',0)
index_whichnot(ol,'a',1)
index_whichnot(ol,'a',2)
'''
length = ol.__len__()
seq = -1
for i in range(0,length):
if(value == ol[i]):
pass
else:
seq = seq + 1
if(seq == which):
return(i)
else:
pass
return(None) |
def indexes_all(ol,value):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
indexes_all(ol,'a')
'''
length = ol.__len__()
indexes =[]
for i in range(0,length):
if(value == ol[i]):
indexes.append(i)
else:
pass
return(indexes) |
def indexes_some(ol,value,*seqs):
'''
from elist.elist import *
ol = [1,'a',3,'a',4,'a',5]
indexes_some(ol,'a',0,2)
indexes_some(ol,'a',0,1)
indexes_some(ol,'a',1,2)
indexes_some(ol,'a',3,4)
'''
seqs = list(seqs)
length = ol.__len__()
indexes =[]
seq = -1
for i in range(0,length):
if(value == ol[i]):
seq = seq + 1
if(seq in seqs):
indexes.append(i)
else:
pass
else:
pass
return(indexes) |
def first_continuous_indexesnot_slice(ol,value):
'''
from elist.elist import *
ol = ["a",0,1,"a","a",2,3,"a",4,"a","a","a",5]
first_continuous_indexesnot_slice(ol,"a")
'''
length = ol.__len__()
begin = None
slice = []
for i in range(0,length):
if(not(ol[i]==value)):
begin = i
break
else:
pass
if(begin == None):
return(None)
else:
slice.append(begin)
for i in range(begin+1,length):
if(not(ol[i]==value)):
slice.append(i)
else:
break
return(slice) |
def last_continuous_indexes_slice(ol,value):
'''
from elist.elist import *
ol = [1,"a","a",2,3,"a",4,"a","a","a",5]
last_continuous_indexes_slice(ol,"a")
'''
length = ol.__len__()
end = None
slice = []
for i in range(length-1,-1,-1):
if(ol[i]==value):
end = i
break
else:
pass
if(end == None):
return(None)
else:
slice.append(end)
for i in range(end-1,-1,-1):
if(ol[i]==value):
slice.append(i)
else:
break
slice.reverse()
return(slice) |
def which_continuous_indexes_slice(ol,value,which):
'''
from elist.elist import *
ol = [1,"a","a",2,3,"a",4,"a","a","a",5]
which_continuous_indexes_slice(ol,"a",0)
which_continuous_indexes_slice(ol,"a",1)
which_continuous_indexes_slice(ol,"a",2)
which_continuous_indexes_slice(ol,"a",3)
which_continuous_indexes_slice(ol,"b",0)
'''
length = ol.__len__()
seq = -1
cursor = 0
begin = None
slice = []
while(cursor < length):
cond1 = (ol[cursor] == value)
cond2 = (begin == None)
if(cond1 & cond2):
begin = cursor
slice.append(cursor)
cursor = cursor + 1
elif(cond1 & (not(cond2))):
slice.append(cursor)
cursor = cursor + 1
elif((not(cond1)) & (not(cond2))):
seq = seq + 1
if(seq == which):
return(slice)
else:
cursor = cursor + 1
begin = None
slice = []
else:
cursor = cursor + 1
if(slice):
seq = seq + 1
else:
pass
if(seq == which):
return(slice)
else:
return([]) |
def seqs_continuous_indexesnot_slices(ol,value,seqs):
'''
from elist.elist import *
ol = [1,"a","a",2,3,"a",4,"a","a","a",5]
seqs_continuous_indexesnot_slices(ol,"a",{0,2})
'''
rslt = []
length = ol.__len__()
seq = -1
cursor = 0
begin = None
slice = []
while(cursor < length):
cond1 = not(ol[cursor] == value)
cond2 = (begin == None)
if(cond1 & cond2):
begin = cursor
slice.append(cursor)
elif(cond1 & (not(cond2))):
slice.append(cursor)
elif((not(cond1)) & (not(cond2))):
seq = seq + 1
if(seq in seqs):
rslt.append(slice)
else:
pass
begin = None
slice = []
else:
pass
cursor = cursor + 1
if(slice):
seq = seq + 1
if(seq in seqs):
rslt.append(slice)
else:
pass
else:
pass
return(rslt) |
def all_continuous_indexes_slices(ol,value):
'''
from elist.elist import *
ol = [1,"a","a",2,3,"a",4,"a","a","a",5]
all_continuous_indexes_slices(ol,"a")
'''
rslt = []
length = ol.__len__()
cursor = 0
begin = None
slice = []
while(cursor < length):
cond1 = (ol[cursor] == value)
cond2 = (begin == None)
if(cond1 & cond2):
begin = cursor
slice.append(cursor)
elif(cond1 & (not(cond2))):
slice.append(cursor)
elif((not(cond1)) & (not(cond2))):
rslt.append(slice)
begin = None
slice = []
else:
pass
cursor = cursor + 1
if(slice):
rslt.append(slice)
else:
pass
return(rslt) |
def shift(ol,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,2,3,4]
id(ol)
rslt = shift(ol)
pobj(rslt)
ol
id(ol)
id(rslt['list'])
####
ol = [1,2,3,4]
id(ol)
rslt = shift(ol,mode="original")
rslt
ol
id(ol)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "new"
length = ol.__len__()
rslt = pop(ol,0,mode=mode)
return(rslt) |
def pop(ol,index,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,2,3,4]
id(ol)
rslt = pop(ol,2)
pobj(rslt)
ol
id(ol)
id(rslt['list'])
####
ol = [1,2,3,4]
id(ol)
rslt = pop(ol,2,mode="original")
rslt
ol
id(ol)
'''
index = uniform_index(index,ol.__len__())
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
new = copy.deepcopy(ol)
popped = new.pop(index)
return({'popped':popped,'list':new})
else:
popped = ol.pop(index)
return(popped) |
def cond_pop(ol,index,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [{'data':0;'type':'number'},{'data':'x';'type':'str'},{'data':'y';'type':'str'},4]
#cond_func_args is a array
def cond_func(index,value,cond_func_args):
'''
cond_func = kwargs['cond_func']
cond_func_args = kwargs['cond_func_args']
index = uniform_index(index,ol.__len__())
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
value = ol[index]
cond = cond_func(index,value,*cond_func_args)
if(mode == "new"):
new = copy.deepcopy(ol)
if(cond):
popped = new.pop(index)
else:
popped = new
return({'popped':popped,'list':new})
else:
if(cond):
popped = ol.pop(index)
else:
popped = ol
return(popped) |
def pop_range(ol,start_index,end_index,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,2,3,4,5,6]
id(ol)
rslt = pop_range(ol,2,4)
ol
id(ol)
id(rslt['list'])
####
ol = [1,2,3,4,5,6]
id(ol)
rslt = pop_range(ol,2,4,mode="original")
rslt
ol
id(ol)
'''
length = ol.__len__()
start_index = uniform_index(start_index,length)
end_index = uniform_index(end_index,length)
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
cpol = copy.deepcopy(ol)
new = []
popped = []
for i in range(0,start_index):
new.append(cpol[i])
for i in range(start_index,end_index):
popped.append(cpol[i])
for i in range(end_index,length):
new.append(cpol[i])
return({'popped':popped,'list':new})
else:
tmp = []
popped = []
for i in range(0,start_index):
tmp.append(ol[i])
for i in range(start_index,end_index):
popped.append(ol[i])
for i in range(end_index,length):
tmp.append(ol[i])
ol.clear()
for i in range(0,tmp.__len__()):
ol.append(tmp[i])
return(popped) |
def pop_indexes(ol,indexes,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,2,3,4,5,6]
id(ol)
rslt = pop_indexes(ol,{0,-3,5})
ol
id(ol)
id(rslt['list'])
####
ol = [1,2,3,4,5,6]
id(ol)
rslt = pop_indexes(ol,{0,-3,5},mode="original")
rslt
ol
id(ol)
'''
length = ol.__len__()
indexes = list(map(lambda index:uniform_index(index,length),list(indexes)))
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
cpol = copy.deepcopy(ol)
new = []
popped = []
for i in range(0,length):
if(i in indexes):
popped.append(cpol[i])
else:
new.append(cpol[i])
return({'popped':popped,'list':new})
else:
tmp = []
popped = []
for i in range(0,length):
if(i in indexes):
popped.append(ol[i])
else:
tmp.append(ol[i])
ol.clear()
for i in range(0,tmp.__len__()):
ol.append(tmp[i])
return(popped) |
def remove_first(ol,value,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,'a',3,'a',5,'a']
id(ol)
new = remove_first(ol,'a')
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a']
id(ol)
rslt = remove_first(ol,'a',mode="original")
ol
rslt
id(ol)
id(rslt)
####array_remove is the same as remove_first
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
new = copy.deepcopy(ol)
new.remove(value)
return(new)
else:
ol.remove(value)
return(ol) |
def remove_firstnot(ol,value,**kwargs):
'''
from elist.jprint import pobj
from elist.elist import *
ol = [1,'a',3,'a',5,'a']
id(ol)
new = remove_firstnot(ol,'a')
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a']
id(ol)
rslt = remove_firstnot(ol,'a',mode="original")
ol
rslt
id(ol)
id(rslt)
####array_removenot is the same as remove_firstnot
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
length = ol.__len__()
if(mode == "new"):
new = copy.deepcopy(ol)
for i in range(0,length):
if(new[i] == value):
pass
else:
new.pop(i)
return(new)
return(new)
else:
for i in range(0,length):
if(ol[i] == value):
pass
else:
ol.pop(i)
return(ol)
return(ol) |
def remove_last(ol,value,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a']
id(ol)
new = remove_last(ol,'a')
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a']
id(ol)
rslt = remove_last(ol,'a',mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
new = copy.deepcopy(ol)
new.reverse()
new.remove(value)
new.reverse()
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def remove_which(ol,value,which,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a']
id(ol)
new = remove_which(ol,'a',1)
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a']
id(ol)
rslt = remove_which(ol,'a',1,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
new = copy.deepcopy(ol)
length = ol.__len__()
if(mode == "new"):
l = new
else:
l = ol
seq = -1
for i in range(0,length):
if(ol[i]==value):
seq = seq + 1
if(seq == which):
l.pop(i)
break
else:
pass
else:
pass
return(l) |
def remove_some(ol,value,*seqs,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = remove_some(ol,'a',1,3)
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = remove_some(ol,'a',1,3,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
seqs = list(seqs)
new = []
length = ol.__len__()
seq = -1
cpol = copy.deepcopy(ol)
for i in range(0,length):
if(cpol[i]==value):
seq = seq + 1
if(seq in seqs):
pass
else:
new.append(cpol[i])
else:
new.append(cpol[i])
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def remove_all(ol,value,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = remove_all(ol,'a')
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = remove_all(ol,'a',mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
new = []
length = ol.__len__()
cpol = copy.deepcopy(ol)
for i in range(0,length):
if(cpol[i]==value):
pass
else:
new.append(cpol[i])
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def remove_many(ol,values,seqs,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]
id(ol)
new = remove_many(ol,['a','b'],[1,2])
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'b',5,'a',6,'a',7,'b',8,'b',9]
id(ol)
rslt = remove_many(ol,['a','b'],[1,2],mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
values = copy.deepcopy(values)
seqs = copy.deepcopy(seqs)
cursors = [-1] * values.__len__()
new = []
length = ol.__len__()
cpol = copy.deepcopy(ol)
for i in range(0,length):
label = True
for j in range(0,cursors.__len__()):
which = seqs[j]
value = values[j]
if(cpol[i] == value):
cursors[j] = cursors[j] + 1
if(cursors[j] == which):
label = False
break
else:
pass
else:
pass
if(label):
new.append(cpol[i])
else:
pass
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def cond_remove_all(ol,**kwargs):
'''
from elist.elist import *
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
def afterCH(ele,ch):
cond = (ord(str(ele)) > ord(ch))
return(cond)
new = cond_remove_all(ol,cond_func=afterCH,cond_func_args=['B'])
ol
new
id(ol)
id(new)
####
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
rslt = cond_remove_all(ol,cond_func=afterCH,cond_func_args=['B'],mode='original')
ol
rslt
id(ol)
id(rslt)
'''
cond_func = kwargs['cond_func']
if('cond_func_args' in kwargs):
cond_func_args = kwargs['cond_func_args']
else:
cond_func_args = []
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
new = copy.deepcopy(ol)
selected = find_all(new,cond_func,*cond_func_args)
selected_indexes = array_map(selected,lambda ele:ele['index'])
new = pop_indexes(new,selected_indexes)['list']
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def cond_remove_some(ol,*some,**kwargs):
'''
from elist.elist import *
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
def afterCH(ele,ch):
cond = (ord(str(ele)) > ord(ch))
return(cond)
new = cond_remove_some(ol,0,2,cond_func=afterCH,cond_func_args=['B'])
ol
new
id(ol)
id(new)
####
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
rslt = cond_remove_some(ol,0,2,cond_func=afterCH,cond_func_args=['B'],mode='original')
ol
rslt
id(ol)
id(rslt)
'''
cond_func = kwargs['cond_func']
if('cond_func_args' in kwargs):
cond_func_args = kwargs['cond_func_args']
else:
cond_func_args = []
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
seqs = list(some)
rslt = cond_remove_seqs(ol,seqs,cond_func=cond_func,cond_func_args=cond_func_args)
return(rslt) |
def init(len,default_element=None):
'''
from elist.elist import *
init(5)
init(5,"x")
'''
rslt = []
for i in range(0,len):
rslt.append(copy.deepcopy(default_element))
return(rslt) |
def array_from(obj,func,*args):
'''
from elist.elist import *
array_from("abcd",None)
#####
def map_func(ele,x,y):
return(int(ele)+x+y)
array_from("1234",map_func,1000,100)
def map_func(ele):
return(int(ele)*2)
array_from("1234",map_func)
array_from("1234",None)
'''
if(func):
l = list(obj)
rslt = list(map(lambda ele:func(ele,*args),l))
return(rslt)
else:
return(list(obj)) |
def copy_within(ol,target, start=None, end=None):
'''
from elist.elist import *
ol = [1, 2, 3, 4, 5]
id(ol)
rslt = copyWithin(ol,0,3,4)
rslt
id(rslt)
####
ol = [1, 2, 3, 4, 5]
id(ol)
rslt = copyWithin(ol,0,3)
rslt
id(rslt)
####
ol = [1, 2, 3, 4, 5]
id(ol)
rslt = copyWithin(ol,-2)
rslt
id(rslt)
####copyWithin is the same as copy_within
'''
length = ol.__len__()
if(start==None):
start = 0
else:
pass
if(end==None):
end = length
else:
pass
target = uniform_index(target,length)
start = uniform_index(start,length)
end = uniform_index(end,length)
cplen = end - start
cpend = target+cplen
if(target+cplen > length):
cpend = length
else:
pass
shift = start - target
if(shift>=0):
for i in range(target,cpend):
ol[i] = ol[i+shift]
else:
for i in range(cpend-1,target-1,-1):
ol[i] = ol[i+shift]
return(ol) |
def reverse(ol,**kwargs):
'''
from elist.elist import *
ol = [1,2,3,4]
id(ol)
new = reverse(ol)
ol
new
id(ol)
id(new)
####
ol = [1,2,3,4]
id(ol)
rslt = reverse(ol,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
if(mode == "new"):
new = copy.deepcopy(ol)
new.reverse()
return(new)
else:
ol.reverse()
return(ol)
'reverse',
'sort' |
def comprise(list1,list2,**kwargs):
'''
from elist.elist import *
comprise([1,2,3,4,5],[2,3,4],mode="loose")
comprise([1,2,3,4,5],[2,3,4])
comprise([1,2,3,4,5],[2,3,4],mode="strict")
comprise([1,2,3,4,5],[1,2,3,4],mode="strict")
#not recursive ,only one level
#please refer to ListTree.search for recursive support
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "loose"
len_1 = list1.__len__()
len_2 = list2.__len__()
if(len_2>len_1):
return(False)
else:
if(mode=="strict"):
if(list2 == list1[:len_2]):
return(True)
else:
return(False)
else:
end = len_1 - len_2
for i in range(0,end+1):
if(list2 == list1[i:(i+len_2)]):
return(True)
else:
pass
return(False) |
def entries(ol):
'''
from elist.elist import *
ol = ['a','b','c']
rslt = entries(ol)
rslt
'''
rslt = []
length = ol.__len__()
for i in range(0,length):
entry = [i,ol[i]]
rslt.append(entry)
return(rslt) |
def splice(ol,start,deleteCount,*eles,**kwargs):
'''
from elist.elist import *
ol = ["angel", "clown", "mandarin", "surgeon"]
id(ol)
new = splice(ol,2,0,"drum")
new
id(new)
####
ol = ["angel", "clown", "mandarin", "surgeon"]
id(ol)
new = splice(ol,2,1,"drum",mode="original")
new
id(new)
####
ol = [1,2,3,4,5,6]
id(ol)
new = splice(ol,2,2,77,777)
new
id(new)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "new"
length = ol.__len__()
new = copy.deepcopy(ol)
if(start >= length):
eles = list(eles)
new.extend(eles)
else:
start = uniform_index(start,length)
end = start + deleteCount
tmp = pop_range(new,start,end,mode="new")['list']
new = insert_some(tmp,*eles,index=start,mode="new")
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def slice(ol,start,end=None,**kwargs):
'''
from elist.elist import *
ol = [1,2,3,4,5]
id(ol)
new = slice(ol,2,4)
new
id(new)
####
id(ol)
rslt = slice(ol,1,-2,mode="original")
rslt
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "new"
length = ol.__len__()
new = copy.deepcopy(ol)
if(end == None):
end = length
else:
end = uniform_index(end,length)
start = uniform_index(start,length)
if(mode == "new"):
return(new[start:end])
else:
ol.clear()
ol.extend(new[start:end])
return(ol) |
def join(ol,separator=","):
'''
from elist.elist import *
ol = [1,2,3,4]
join(ol,separator="-")
'''
if(ol.__len__() == 0):
return("")
else:
pass
cond = (type(ol[0])==type(b''))
if(cond):
rslt = b''
else:
rslt =""
length = ol.__len__()
for i in range(0,length-1):
ele = ol[i]
if(cond):
pass
else:
ele = str(ele)
rslt = rslt + ele + separator
if(cond):
rslt = rslt + ol[length - 1]
else:
rslt = rslt + str(ol[length - 1])
return(rslt) |
def join2(ol,*sps):
'''
from elist.elist import *
ol = [1,2,3,4]
join2(ol,"-","+","*")
'''
rslt =""
length = ol.__len__()
for i in range(0,length-1):
rslt = rslt + str(ol[i]) + sps[i]
rslt = rslt + str(ol[length - 1])
return(rslt) |
def htmljoin(ol,sp,**kwargs):
'''
ol = [1,2,3,4]
htmljoin(ol,"option",outer="select")
'''
if('outer' in kwargs):
outer = kwargs['outer']
else:
outer = ""
if(outer):
head = "<" + outer + ">"
tail = "</" + outer + ">"
else:
head = ""
tail = ""
rslt = head
length = ol.__len__()
begin = "<" + sp + ">"
end = "</" + sp + ">"
for i in range(0,length):
rslt = rslt + begin + str(ol[i]) + end
rslt = rslt + tail
return(rslt) |
def uniqualize(l,**kwargs):
'''
from elist.elist import *
l = [1, 2, 2]
new = uniqualize(l)
new
id(l)
id(new)
####
l = [1, 2, 2]
rslt = uniqualize(l,mode="original")
rslt
id(l)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = 'new'
pt = copy.deepcopy(l)
seqs =[]
freq = {}
for i in range(0,pt.__len__()):
v = pt[i]
if(v in freq):
freq[v] = freq[v] + 1
else:
freq[v] = 0
seqs.append(i)
#####下面是影响速度的关键,append特别耗时
npt = select_seqs(pt,seqs)
########################
pt = npt
if(mode == 'new'):
return(npt)
else:
l.clear()
l.extend(npt)
return(l) |
def cond_uniqualize(l,**kwargs):
'''
from elist.elist import *
l = [('BIGipServer', 'rd100'), ('TS013d8ed5', '00A0'), ('BIGipServer', 'rd200'), ('TS013d8ed5', '00B0'), ('SID', '1'), ('SID', '2')]
def cond_func(ele,*args):
cond = ele[0]
return(cond)
uniqualized = cond_uniqualize(l,cond_func=cond_func)
pobj(uniqualized)
l = [('BIGipServer', 'rd100'), ('TS013d8ed5', '00A0'), ('BIGipServer', 'rd200'), ('TS013d8ed5', '00B0'), ('SID', '1'), ('SID', '2')]
reserved_mapping = {'BIGipServer':0,'TS013d8ed5':1,'SID':1}
uniqualized = cond_uniqualize(l,cond_func=cond_func,reserved_mapping=reserved_mapping)
pobj(uniqualized)
'''
cond_func = kwargs['cond_func']
if('cond_func_args' in kwargs):
cond_func_args = kwargs['cond_func_args']
else:
cond_func_args = []
if('reserved_mapping' in kwargs):
reserved_mapping = kwargs['reserved_mapping']
else:
reserved_mapping = None
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = 'new'
desc = cond_value_indexes_mapping(l,cond_func=cond_func,cond_func_args=cond_func_args,with_none=True)
keys = list(desc.keys())
if(None in keys):
keys.remove(None)
else:
pass
rmapping = {}
for key in keys:
rmapping[key] = 0
if(reserved_mapping == None):
pass
else:
for key in reserved_mapping:
rmapping[key] = reserved_mapping[key]
reserved_indexes = []
for key in keys:
indexes = desc[key]
index = indexes[rmapping[key]]
reserved_indexes.append(index)
newcopy = copy.deepcopy(l)
new = select_seqs(newcopy,reserved_indexes)
####
if(None in desc):
for index in desc[None]:
new.append(newcopy[index])
else:
pass
####
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def interleave(*arrays,**kwargs):
'''
arr1 = [1,2,3,4]
arr2 = ['a','b','c','d']
arr3 = ['@','#','%','*']
interleave(arr1,arr2,arr3)
'''
anum = arrays.__len__()
rslt = []
length = arrays[0].__len__()
for j in range(0,length):
for i in range(0,anum):
array = arrays[i]
rslt.append(array[j])
return(rslt) |
def deinterleave(ol,gnum):
'''
ol = [1, 2, 3, 4, 5, 6, 7, 8, 9]
deinterleave(ol,3)
'''
def test_func(ele,index,interval,which):
cond= (index % interval == which)
return(cond)
rslt = []
for i in range(0,gnum):
arr = cond_select_all2(ol,cond_func = test_func,cond_func_args = [gnum,i])
rslt.append(arr)
return(rslt) |
def for_each(ol,test_func,*args):
'''
from elist.elist import *
def show_func(ele):
print("<{0}>".format(ele))
ol = [1,2,3,4]
for_each(ol,show_func)
####forEach is the same as for_each
####forEach have no return value
'''
rslt = (True,None)
length = ol.__len__()
for i in range(0,length):
test_func(ol[i],*args) |
def loose_in(pl,k):
'''
pl = ['bcd','xabcxx','x','y']
loose_in(pl,'abc')
'''
cond = some(pl,lambda ele:(k in ele))['cond']
return(cond) |
def select_loose_in(pl,k):
'''
pl = ['bcd','xabcxx','x','y']
select_loose_in(pl,'abc')
'''
def cond_func(ele,index,k):
if(type(ele) == type([])):
cond = loose_in(ele,k)
else:
cond = (k in ele)
return(cond)
arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[k])
return(arr) |
def select_strict_in(pl,k):
'''
pl = ['bcd','xabcxx','x','y']
select_strict_in(pl,'abc')
'''
def cond_func(ele,index,k):
if(type(ele) == type([])):
cond = (k in ele)
else:
cond = (k == ele)
return(cond)
arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[k])
return(arr) |
def regex_in(pl,regex):
'''
regex = re.compile("^[a-z]+$")
pl = ['b1c3d','xab15cxx','1x','y2']
regex_in(pl,regex)
regex = re.compile("^[0-9a-z]+$")
pl = ['b1c3d','xab15cxx','1x','y2']
regex_in(pl,regex)
'''
def cond_func(ele,regex):
m = regex.search(ele)
if(m == None):
return(False)
else:
return(True)
cond = some(pl,cond_func,regex)['cond']
return(cond) |
def select_regex_in(pl,regex):
'''
regex = re.compile("^x.*x$")
pl = ['bcd','xabcxx','xx','y']
select_regex_in(pl,'abc')
'''
def cond_func(ele,index,regex):
if(type(ele)==type([])):
cond = regex_in(ele,regex)
else:
m = regex.search(ele)
if(m == None):
cond = False
else:
cond = True
return(cond)
arr = cond_select_values_all2(pl,cond_func=cond_func, cond_func_args =[regex])
return(arr) |
def some(ol,test_func,*args):
'''
from elist.elist import *
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4]
some(ol,test_func,3)
ol = [1,2,1,3]
some(ol,test_func,3)
'''
rslt = {'cond':False,'index':None}
length = ol.__len__()
for i in range(0,length):
cond = test_func(ol[i],*args)
if(cond):
return({'cond':True,'index':i})
else:
pass
return(rslt) |
def fill(ol,value,start=None, end=None,**kwargs):
'''
from elist.elist import *
ol = [1, 2, 3,4,5]
id(ol)
rslt = fill(ol,4)
rslt
id(rslt)
####
ol = [1, 2, 3,4,5]
id(ol)
rslt = fill(ol,4,1)
rslt
id(rslt)
####
ol = [1, 2, 3,4,5]
id(ol)
rslt = fill(ol,6,1,3,mode="original")
rslt
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "new"
length = ol.__len__()
if(start==None):
start = 0
else:
pass
if(end==None):
end = length
else:
pass
start = uniform_index(start,length)
end = uniform_index(end,length)
new = copy.deepcopy(ol)
for i in range(start,end):
new[i] = value
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def filter(ol,test_func,*args,**kwargs):
'''
from elist.elist import *
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4]
id(ol)
new = filter(ol,test_func,3)
new
id(new)
#####
ol = [10,20,30,40]
id(ol)
rslt = filter(ol,test_func,3,mode="original")
rslt
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs['mode']
else:
mode = "new"
length = ol.__len__()
new = []
cpol = copy.deepcopy(ol)
for i in range(0,length):
cond = test_func(cpol[i],*args)
if(cond):
new.append(cpol[i])
else:
pass
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def find_last(ol,test_func,*args):
'''
from elist.elist import *
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4]
last = find_last(ol,test_func,3)
last
#####
ol = [10,20,30,40]
last = find_last(ol,test_func,3)
last
'''
length = ol.__len__()
for i in range(length-1,-1,-1):
cond = test_func(ol[i],*args)
if(cond):
return({'index':i,'value':ol[i]})
else:
pass
return({'index':None,'value':None}) |
def find_which(ol,which,test_func,*args):
'''
from elist.elist import *
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4,5,6,7]
last = find_which(ol,0,test_func,3)
last
last = find_which(ol,2,test_func,3)
last
'''
length = ol.__len__()
seq = -1
for i in range(0,length):
cond = test_func(ol[i],*args)
if(cond):
seq = seq + 1
if(seq == which):
return({'index':i,'value':ol[i]})
else:
pass
else:
pass
return({'index':None,'value':None}) |
def find_seqs(ol,seqs,test_func,*args):
'''
from elist.elist import *
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4,5,6,7]
some = find_seqs(ol,[0,3],test_func,3)
some
some = find_some(ol,[0,1,2],test_func,3)
some
#find_some is the same as find_seqs
'''
rslt =[]
seqs = list(seqs)
length = ol.__len__()
seq = -1
for i in range(0,length):
cond = test_func(ol[i],*args)
if(cond):
seq = seq + 1
if(seq in seqs):
rslt.append({'index':i,'value':ol[i]})
else:
pass
else:
pass
return(rslt) |
def find_allnot(ol,test_func,*args):
'''
from elist.elist import *
from elist.jprint import pobj
def test_func(ele,x):
cond = (ele > x)
return(cond)
ol = [1,2,3,4,5,6,7]
rslt = find_allnot(ol,test_func,3)
pobj(rslt)
'''
rslt =[]
length = ol.__len__()
for i in range(0,length):
cond = test_func(ol[i],*args)
if(cond):
pass
else:
rslt.append({'index':i,'value':ol[i]})
return(rslt) |
def reduce_left(ol,callback,initialValue):
'''
from elist.elist import *
def callback(accumulator,currentValue):
accumulator.append(currentValue[0])
accumulator.append(currentValue[1])
return(accumulator)
ol = [(1,2),("a","b"),("x","y")]
reduce_left(ol,callback,[])
#array_reduce, reduceLeft ,reduce_left are the same
'''
length = ol.__len__()
accumulator = initialValue
for i in range(0,length):
accumulator = callback(accumulator,ol[i])
return(accumulator) |
def diff_indexes(l1,l2):
'''
from elist.elist import *
l1 = [1,2,3,5]
l2 = [0,2,3,4]
diff_indexes(l1,l2)
'''
rslt = []
for i in range(0,l1.__len__()):
if(l1[i]!=l2[i]):
rslt.append(i)
return(rslt) |
def diff_values(l1,l2):
'''
from elist.elist import *
l1 = [1,2,3,5]
l2 = [0,2,3,4]
diff_values(l1,l2)
'''
rslt = []
for i in range(0,l1.__len__()):
if(l1[i]!=l2[i]):
rslt.append(l1[i])
return(rslt) |
def same_indexes(l1,l2):
'''
from elist.elist import *
l1 = [1,2,3,5]
l2 = [0,2,3,4]
same_indexes(l1,l2)
'''
rslt = []
for i in range(0,l1.__len__()):
if(l1[i]==l2[i]):
rslt.append(i)
return(rslt) |
def same_values(l1,l2):
'''
from elist.elist import *
l1 = [1,2,3,5]
l2 = [0,2,3,4]
same_values(l1,l2)
'''
rslt = []
for i in range(0,l1.__len__()):
if(l1[i]==l2[i]):
rslt.append(l1[i])
return(rslt) |
def value_indexes_mapping(l):
'''
from elist.elist import *
from elist.jprint import pobj
l = ['a','b','b','a','c','b']
desc = value_indexes_mapping(l)
pobj(desc)
'''
pt = copy.deepcopy(l)
desc = {}
vset = set({})
for v in pt:
vset.add(v)
for v in vset:
desc[v] = []
for i in range(0,l.__len__()):
desc[l[i]].append(i)
return(desc) |
def cond_value_indexes_mapping(l,**kwargs):
'''
from elist.elist import *
l = [('BIGipServer', 'rd19'), ('TS013d8ed5', '0105b6b0'), ('BIGipServer', 'rd19'), ('TS013d8ed5', '0105b6b0'), ('SID', '1'), ('SID', '2')]
def cond_func(ele,*args):
cond = ele[0]
return(cond)
desc = cond_value_indexes_mapping(l,cond_func=cond_func)
pobj(desc)
'''
cond_func = kwargs['cond_func']
if('cond_func_args' in kwargs):
cond_func_args = kwargs['cond_func_args']
else:
cond_func_args = []
if('with_none' in kwargs):
with_none = kwargs['with_none']
else:
with_none = False
desc = {}
for i in range(0,l.__len__()):
ele = l[i]
cond = cond_func(ele,*cond_func_args)
if((cond == None)&(not(with_none))):
pass
else:
if(cond in desc):
desc[cond].append(i)
else:
desc[cond] = [i]
return(desc) |
def getitem_via_pathlist(ol,pathlist):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
getitem_via_pathlist(y,[1,1])
'''
this = ol
for i in range(0,pathlist.__len__()):
key = pathlist[i]
this = this.__getitem__(key)
return(this) |
def getitem_via_sibseqs(ol,*sibseqs):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
getitem_via_sibseqs(y,1,1)
'''
pathlist = list(sibseqs)
this = ol
for i in range(0,pathlist.__len__()):
key = pathlist[i]
this = this.__getitem__(key)
return(this) |
def setitem_via_pathlist(ol,value,pathlist):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
setitem_via_pathlist(y,"500",[1,1])
y
'''
this = ol
for i in range(0,pathlist.__len__()-1):
key = pathlist[i]
this = this.__getitem__(key)
this.__setitem__(pathlist[-1],value)
return(ol) |
def setitem_via_sibseqs(ol,value,*sibseqs):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
setitem_via_sibseqs(y,"500",1,1)
y
'''
this = ol
pathlist = list(sibseqs)
for i in range(0,pathlist.__len__()-1):
key = pathlist[i]
this = this.__getitem__(key)
this.__setitem__(pathlist[-1],value)
return(ol) |
def delitem_via_pathlist(ol,pathlist):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
delitem_via_pathlist(y,[1,1])
y
'''
this = ol
for i in range(0,pathlist.__len__()-1):
key = pathlist[i]
this = this.__getitem__(key)
this.__delitem__(pathlist[-1])
return(ol) |
def delitem_via_sibseqs(ol,*sibseqs):
'''
from elist.elist import *
y = ['a',['b',["bb"]],'c']
y[1][1]
delitem_via_sibseqs(y,1,1)
y
'''
pathlist = list(sibseqs)
this = ol
for i in range(0,pathlist.__len__()-1):
key = pathlist[i]
this = this.__getitem__(key)
this.__delitem__(pathlist[-1])
return(ol) |
def replace_seqs(ol,value,indexes,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = replace_seqs(ol,'AAA',[1,3,7])
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = replace_seqs(ol,'AAA',[1,3,7],mode="original")
ol
rslt
id(ol)
id(rslt)
#replace_indexes = replace_seqs
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
indexes = list(indexes)
new = []
length = ol.__len__()
cpol = copy.deepcopy(ol)
for i in range(0,length):
if(i in indexes):
new.append(value)
else:
new.append(cpol[i])
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def replace_some(ol,value,*indexes,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = replace_some(ol,'AAA',1,3,7)
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = replace_some(ol,'AAA',1,3,7,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
indexes = list(indexes)
return(replace_seqs(ol,value,indexes,mode=mode)) |
def replace_value_seqs(ol,src_value,dst_value,seqs,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = replace_value_seqs(ol,'a','AAA',[0,1])
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = replace_value_seqs(ol,'a','AAA',[0,1],mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
indexes = indexes_seqs(ol,src_value,seqs)
return(replace_indexes(ol,dst_value,indexes,mode=mode)) |
def replace_value_some(ol,src_value,dst_value,*seqs,**kwargs):
'''
from elist.elist import *
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
new = replace_value_some(ol,'a','AAA',0,1)
ol
new
id(ol)
id(new)
####
ol = [1,'a',3,'a',5,'a',6,'a']
id(ol)
rslt = replace_value_some(ol,'a','AAA',0,1,mode="original")
ol
rslt
id(ol)
id(rslt)
'''
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
return(replace_value_seqs(ol,src_value,dst_value,list(seqs),mode=mode)) |
def cond_replace_value_some(ol,dst_value,*some,**kwargs):
'''
from elist.elist import *
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
def afterCH(ele,ch):
cond = (ord(str(ele)) > ord(ch))
return(cond)
new = cond_replace_value_some(ol,"REPLACED",0,2,cond_func=afterCH,cond_func_args=['B'])
ol
new
id(ol)
id(new)
####
ol = [1,'X',3,'b',5,'c',6,'A',7,'b',8,'B',9]
id(ol)
rslt = cond_replace_value_some(ol,"REPLACED",0,2,cond_func=afterCH,cond_func_args=['B'],mode="original")
ol
rslt
id(ol)
id(rslt)
'''
cond_func = kwargs['cond_func']
if('cond_func_args' in kwargs):
cond_func_args = kwargs['cond_func_args']
else:
cond_func_args = []
if('mode' in kwargs):
mode = kwargs["mode"]
else:
mode = "new"
seqs = list(some)
new = copy.deepcopy(ol)
selected = find_all(new,cond_func,*cond_func_args)
selected_indexes = array_map(selected,lambda ele:ele['index'])
selected_indexes = select_seqs(selected_indexes,seqs)
new = replace_seqs(new,dst_value,selected_indexes)
if(mode == "new"):
return(new)
else:
ol.clear()
ol.extend(new)
return(ol) |
def rangize(break_points,length):
'''
break_points = [1,3,9,12,-2]
length = 15
secs = rangize(break_points,length)
forEach(secs,print)
'''
bps = array_map(break_points,uniform_index,length)
bps.sort()
bps = prepend(bps,0)
bps = append(bps,length)
bps = uniqualize(bps)
bpslen = bps.__len__()
secs=[(0,bps[0])]
for i in range(0,bpslen-1):
r = (bps[i],bps[i+1])
secs.append(r)
secs.append((bps[bpslen-1],length))
if(secs[0][0] == secs[0][1]):
secs.pop(0)
else:
pass
if(secs[-1][0] == secs[-1][1]):
secs.pop(-1)
else:
pass
return(secs) |
def rangize_supplement(spans,lngth):
'''
spans = [(0, 3), (4, 7), (8, 10), (11, 12), (13, 16), (17, 20)]
rangize_supplement(spans,24)
'''
rslt = []
si = 0
ei = spans[0][0]
if(si == ei):
pass
else:
rslt.append((si,ei))
prev_ei = spans[0][1]
for i in range(1,spans.__len__()):
si = prev_ei
ei = spans[i][0]
rslt.append((si,ei))
prev_ei = spans[i][1]
if(prev_ei < lngth):
rslt.append((prev_ei,lngth))
else:
rslt.append((prev_ei,lngth+1))
return(rslt) |
def range_compress(ol):
'''
#only support sorted-ints or sorted-ascii
l = [1,5,6,7,8,13,14,18,30,31,32,33,34]
range_compress(l)
l = [1,5,6,7,8,13,14,18,30,31,32,33,34,40]
range_compress(l)
l = ['a','b','c','d','j','k','l','m','n','u','y','z']
range_compress(l)
'''
T = (type(ol[0]) == type(0))
if(T):
l = ol
else:
l = array_map(ol,ord)
length = l.__len__()
secs = []
si = 0
ei = 0
prev = l[0]
for i in range(1,length):
curr = l[i]
cond = (curr == (prev+1))
if(cond):
ei = i
prev = curr
else:
if(T):
sec = (l[si],l[ei])
else:
sec = (ol[si],ol[ei])
if(si == ei):
sec = sec[0]
else:
pass
secs.append(sec)
si = i
ei = i
prev = curr
if(T):
sec = (l[si],l[ei])
else:
sec = (ol[si],ol[ei])
if(si == ei):
sec = sec[0]
else:
pass
secs.append(sec)
return(secs) |
def range_decompress(cl):
'''
#only support sorted-ints or sorted-ascii
cl = [1, (5, 8), (13, 14), 18, (30, 34)]
range_decompress(cl)
cl = [1, (5, 8), (13, 14), 18, (30, 34), 40]
range_decompress(cl)
cl = [('a', 'd'), ('j', 'n'), 'u', ('y', 'z')]
range_decompress(cl)
'''
def cond_func(ele):
length = ele.__len__()
cond = (length == 1)
if(cond):
return(ord(ele))
else:
x = ord(ele[0])
y = ord(ele[1])
return((x,y))
if(type(cl[0])==type(0)):
T = True
elif(cl[0].__len__() == 1):
T = (type(cl[0]) == type(0))
else:
T = (type(cl[0][0]) == type(0))
if(T):
l = cl
else:
l = array_map(cl,cond_func)
rslt = []
for i in range(0,l.__len__()):
ele = l[i]
if(type(ele) == type(0)):
arr = [ele]
elif(ele.__len__() == 1):
arr = [ele]
else:
sv = ele[0]
ev = ele[1]
arr = init_range(sv,ev+1,1)
if(T):
pass
else:
arr = array_map(arr,chr)
rslt.extend(arr)
return(rslt) |
def broken_seqs(ol,break_points):
'''
ol = initRange(0,20,1)
ol
break_points = [1,6,14,9]
secs = broken_seqs(ol,break_points)
forEach(secs,print)
'''
bps = list(break_points)
length = ol.__len__()
rgs = rangize(bps,length)
rslt = []
for i in range(0,rgs.__len__()):
si,ei = rgs[i]
sec = ol[si:ei]
rslt.append(sec)
return(rslt) |
def brkl2kvlist(arr,interval,sub_pos=1,**kwargs):
'''
arr = ["color1","r1","g1","b1","a1","color2","r2","g2","b2","a2"]
brkl2kvlist(arr,5)
(['color1', 'color2'], [['r1', 'g1', 'b1', 'a1'], ['r2', 'g2', 'b2', 'a2']])
brkl2kvlist(arr,5,2)
([['color1', 'r1'], ['color2', 'r2']], [['g1', 'b1', 'a1'], ['g2', 'b2', 'a2']])
'''
lngth = arr.__len__()
brkseqs1 = init_range(0,lngth,interval)
brkseqs2 = init_range(sub_pos,lngth,interval)
brkseqs = interleave(brkseqs1,brkseqs2)
l = broken_seqs(arr,brkseqs)
kl = select_evens(l)
vl = select_odds(l)
if("single_key" in kwargs):
single_key = kwargs['single_key']
else:
single_key = True
if(sub_pos == 1):
if(single_key):
kl = mapv(kl,lambda ele:ele[0])
else:
pass
else:
pass
return((kl,vl)) |
def divide(ol,interval):
'''
ol = elel.initRange(0,20,1)
interval = 3
rslt = elel.divide(ol,interval)
rslt
rslt = elel.divide(ol,4)
rslt
'''
length = ol.__len__()
seqs = initRange(0,length,interval)
rslt = broken_seqs(ol,seqs)
return(rslt) |
def split(ol,value,**kwargs):
'''
ol = ['a',1,'a',2,'a',3,'a',4,'a']
split(ol,'a')
split(ol,'a',whiches=[0])
split(ol,'a',whiches=[1])
split(ol,'a',whiches=[2])
split(ol,'a',whiches=[0,2])
ol = [1,'a',2,'a',3,'a',4]
split(ol,'a')
split('x=bcdsef=g','=',whiches=[0])
'''
if('whiches' in kwargs):
whiches = kwargs['whiches']
else:
whiches = None
indexes = indexes_all(ol,value)
if(whiches == None):
pass
else:
indexes = select_indexes(indexes,whiches)
rslt = []
rslt.append(ol[:indexes[0]])
si = indexes[0]+1
for i in range(1,indexes.__len__()):
ei = indexes[i]
ele = ol[si:ei]
rslt.append(ele)
si = ei + 1
ele = ol[si:ol.__len__()]
rslt.append(ele)
return(rslt) |
def where(ol,value):
'''
ol = [0, 4, 6, 8, 10, 14]
where(ol,-1)
where(ol,1)
where(ol,2)
where(ol,3)
where(ol,4)
where(ol,9)
where(ol,14)
where(ol,17)
'''
si = None
ei = None
for i in range(0,ol.__len__()):
ele = ol[i]
if(value >ele):
si = i
elif(value == ele):
return((i,i))
else:
ei = i
return((si,ei))
return((si,ei)) |
def value_interval(ol,value):
'''
ol = [0, 4, 6, 8, 10, 14]
value_interval(ol,-1)
value_interval(ol,1)
value_interval(ol,2)
value_interval(ol,3)
value_interval(ol,4)
value_interval(ol,9)
value_interval(ol,14)
value_interval(ol,17)
'''
si,ei = where(ol,value)
if(si == None):
sv = None
else:
sv = ol[si]
if(ei == None):
ev = None
else:
ev = ol[ei]
return((sv,ev)) |
def rand_sub(arr,*args,**kwargs):
'''
arr = ['scheme', 'username', 'password', 'hostname', 'port', 'path', 'params', 'query', 'fragment']
rand_sub(arr,3)
rand_sub(arr,3)
rand_sub(arr,3)
rand_sub(arr)
rand_sub(arr)
rand_sub(arr)
'''
arr = copy.deepcopy(arr)
lngth = arr.__len__()
args = list(args)
if(args.__len__() == 0):
n = random.randrange(0,lngth)
else:
n = args[0]
if(n>lngth):
n = lngth
else:
pass
indexes = rand_some_indexes(0,lngth,n,**kwargs)
narr = select_seqs_keep_order(arr,indexes)
return(narr) |
def is_leaf(obj):
'''
the below is for nested-list
any type is not list will be treated as a leaf
empty list will be treated as a leaf
from elist.elist import *
is_leaf(1)
is_leaf([1,2,3])
is_leaf([])
'''
if(is_list(obj)):
length = obj.__len__()
if(length == 0):
return(True)
else:
return(False)
else:
return(True) |
def new_ele_description(**kwargs):
'''
from elist.elist import *
from elist.jprint import pobj
root_desc = new_ele_description(leaf=False,depth=0,breadth_path=[],path=[],parent_path=[],parent_breadth_path=[])
pobj(root_desc)
#None means not handled
'''
desc = {
'leaf':None,
'depth':None,
'breadth':None,
'breadth_path':None,
'sib_seq':None,
'path':None,
'parent_path':None,
'parent_breadth_path':None,
'lsib_path':None,
'rsib_path':None,
'lcin_path':None,
'rcin_path':None,
'sons_count':None,
'leaf_son_paths':None,
'non_leaf_son_paths':None,
'leaf_descendant_paths':None,
'non_leaf_descendant_paths':None,
'flat_offset':None,
'flat_len':None
}
for key in kwargs:
desc[key.lower()] = kwargs[key]
return(desc) |
def init_desc_matrix(l):
'''
from elist.elist import *
from elist.jprint import pobj
l = [1,[4],2,[3,[5,6]]]
desc_matrix = init_desc_matrix(l)
pobj(desc_matrix)
'''
leaf = is_leaf(l)
root_desc = new_ele_description(leaf=leaf,depth=0,breadth_path=[],path=[],parent_path=[],parent_breadth_path=[])
if(leaf):
root_desc['sons_count'] = 0
else:
pass
desc_matrix = [
[root_desc]
]
return(desc_matrix) |
def _init_unhandled(l,inited_matrix):
'''
from elist.elist import *
from elist.jprint import pobj
l = [1,[4],2,[3,[5,6]]]
desc_matrix = init_desc_matrix(l)
unhandled = _init_unhandled(l,desc_matrix)
unhandled_data = unhandled['data']
unhandled_desc = unhandled['desc']
unhandled_data[0]
unhandled_desc[0]
unhandled_data[1]
unhandled_desc[1]
'''
root_desc = inited_matrix[0][0]
unhandled = {'data':[],'desc':[]}
length = l.__len__()
root_desc['sons_count'] = length
root_desc['leaf_son_paths'] = []
root_desc['non_leaf_son_paths'] = []
if(length == 0):
pass
else:
inited_matrix.append([])
level = inited_matrix[1]
for i in range(0,length):
child = l[i]
desc = copy.deepcopy(root_desc)
desc = reset_parent_desc_template(desc)
desc['depth'] = 1
desc['breadth'] = i
desc['parent_breadth_path'] = copy.deepcopy(desc['breadth_path'])
desc['breadth_path'].append(i)
desc['sib_seq'] = i
desc['parent_path'] = copy.deepcopy(desc['path'])
desc['path'].append(i)
if(i==0):
pass
else:
desc['lsib_path'] = [i-1]
if(i == (length - 1)):
pass
else:
desc['rsib_path'] = [i+1]
if(is_leaf(child)):
desc['leaf'] = True
desc['sons_count'] = 0
root_desc['leaf_son_paths'].append(copy.deepcopy(desc['path']))
else:
desc['leaf'] = False
root_desc['non_leaf_son_paths'].append(copy.deepcopy(desc['path']))
unhandled['data'].append(child)
unhandled['desc'].append(desc)
level.append(desc)
return(unhandled) |
def update_desc_lsib_path(desc):
'''
leftSibling
previousSibling
leftSib
prevSib
lsib
psib
have the same parent,and on the left
'''
if(desc['sib_seq']>0):
lsib_path = copy.deepcopy(desc['path'])
lsib_path[-1] = desc['sib_seq']-1
desc['lsib_path'] = lsib_path
else:
pass
return(desc) |
def update_desc_rsib_path(desc,sibs_len):
'''
rightSibling
nextSibling
rightSib
nextSib
rsib
nsib
have the same parent,and on the right
'''
if(desc['sib_seq']<(sibs_len-1)):
rsib_path = copy.deepcopy(desc['path'])
rsib_path[-1] = desc['sib_seq']+1
desc['rsib_path'] = rsib_path
else:
pass
return(desc) |
def update_desc_lcin_path(desc,pdesc_level):
'''
leftCousin
previousCousin
leftCin
prevCin
lcin
pcin
parents are neighbors,and on the left
'''
parent_breadth = desc['parent_breadth_path'][-1]
if(desc['sib_seq']==0):
if(parent_breadth==0):
pass
else:
parent_lsib_breadth = parent_breadth - 1
plsib_desc = pdesc_level[parent_lsib_breadth]
if(plsib_desc['leaf']):
pass
else:
lcin_path = copy.deepcopy(plsib_desc['path'])
lcin_path.append(plsib_desc['sons_count'] - 1)
desc['lcin_path'] = lcin_path
else:
pass
return(desc) |
def update_desc_rcin_path(desc,sibs_len,pdesc_level):
'''
rightCousin
nextCousin
rightCin
nextCin
rcin
ncin
parents are neighbors,and on the right
'''
psibs_len = pdesc_level.__len__()
parent_breadth = desc['parent_breadth_path'][-1]
if(desc['sib_seq']==(sibs_len - 1)):
if(parent_breadth==(psibs_len -1)):
pass
else:
parent_rsib_breadth = parent_breadth + 1
prsib_desc = pdesc_level[parent_rsib_breadth]
#because from left to right to handle each level
#sons_count will only be updated in the next-round
if(prsib_desc['leaf']):
pass
else:
rcin_path = copy.deepcopy(prsib_desc['path'])
rcin_path.append(0)
desc['rcin_path'] = rcin_path
else:
pass
return(desc) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.