本文整理汇总了Python中python_compat.sorted函数的典型用法代码示例。如果您正苦于以下问题：Python sorted函数的具体用法？Python sorted怎么用？Python sorted使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了sorted函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: jobs
def jobs(self, *args, **kw):
result = '<body>'
result += str(CPProgressBar(0, min(100, self.counter), 100, 300))
if 'job' in kw:
jobNum = int(kw['job'])
info = self.task.getJobConfig(jobNum)
result += str(TabularHTML(zip(sorted(info), sorted(info)), [info], top = False))
def getJobObjs():
for jobNum in self.jobMgr.jobDB.getJobs():
result = self.jobMgr.jobDB.get(jobNum).__dict__
result['jobNum'] = jobNum
result.update(result['dict'])
yield result
fmtTime = lambda t: time.strftime('%Y-%m-%d %T', time.localtime(t))
result += str(TabularHTML([
('jobNum', 'Job'), ('state', 'Status'), ('attempt', 'Attempt'),
('wmsId', 'WMS ID'), ('dest', 'Destination'), ('submitted', 'Submitted')
], getJobObjs(),
fmt = {
'jobNum': lambda x: '<a href="jobs?job=%s">%s</a>' % (x, x),
'state': lambda s: Job.enum2str(s),
'submitted': fmtTime
}, top = True))
result += '</body>'
return result示例2: write
def write(self, stream, entries = None, printMinimal = False, printState = False,
printUnused = True, printSource = False, printDefault = True, printTight = False):
if not entries:
entries = self.iterContent()
config = {}
for entry in entries:
if printUnused or entry.accessed:
if printDefault or not entry.source.startswith('<default'):
if printState or not entry.option.startswith('#'):
config.setdefault(entry.section, {}).setdefault(entry.option, []).append(entry)
for section in sorted(config):
if not printTight:
stream.write('[%s]\n' % section)
for option in sorted(config[section]):
entryList = sorted(config[section][option], key = lambda e: e.order)
if printMinimal:
entryList = ConfigEntry.simplifyEntries(entryList)
for entry in entryList:
if printTight:
stream.write('[%s] ' % section)
for idx, line in enumerate(entry.format().splitlines()):
if printSource and (idx == 0) and entry.source:
if len(line) < 33:
stream.write('%-35s; %s\n' % (line, entry.source))
else:
stream.write('; source: %s\n%s\n' % (entry.source, line))
else:
stream.write(line + '\n')
if not printTight:
stream.write('\n')示例3: __init__
def __init__(self, jobDB, task, jobs = None, configString = ''):
Report.__init__(self, jobDB, task, jobs, configString)
catJobs = {}
catDescDict = {}
# Assignment of jobs to categories (depending on variables and using datasetnick if available)
for jobNum in self._jobs:
jobConfig = task.getJobConfig(jobNum)
varList = sorted(filter(lambda var: '!' not in repr(var), jobConfig.keys()))
if 'DATASETSPLIT' in varList:
varList.remove('DATASETSPLIT')
varList.append('DATASETNICK')
catKey = str.join('|', map(lambda var: '%s=%s' % (var, jobConfig[var]), varList))
catJobs.setdefault(catKey, []).append(jobNum)
if catKey not in catDescDict:
catDescDict[catKey] = dict(map(lambda var: (var, jobConfig[var]), varList))
# Kill redundant keys from description
commonVars = dict(map(lambda var: (var, jobConfig[var]), varList)) # seed with last varList
for catKey in catDescDict:
for key in commonVars.keys():
if key not in catDescDict[catKey].keys():
commonVars.pop(key)
elif commonVars[key] != catDescDict[catKey][key]:
commonVars.pop(key)
for catKey in catDescDict:
for commonKey in commonVars:
catDescDict[catKey].pop(commonKey)
# Generate job-category map with efficient int keys - catNum becomes the new catKey
self._job2cat = {}
self._catDescDict = {}
for catNum, catKey in enumerate(sorted(catJobs)):
self._catDescDict[catNum] = catDescDict[catKey]
self._job2cat.update(dict.fromkeys(catJobs[catKey], catNum))示例4: get_plugin_list
def get_plugin_list(pname, inherit_prefix=False):
alias_dict = {}
inherit_map = {}
cls = Plugin.get_class(pname)
for entry in cls.get_class_info_list():
depth = entry.pop('depth', 0)
(alias, name) = entry.popitem()
alias_dict.setdefault(name, []).append((depth, alias))
def _process_child_map(mapping, prefix=''):
for cls_name in mapping:
inherit_map[cls_name] = _process_child_map(mapping[cls_name], prefix + '-' + cls_name)
return prefix
_process_child_map(cls.get_class_children(), pname)
alias_dict.pop(pname, None)
table_list = []
for name in alias_dict:
# sorted by length of name and depth
by_len_depth = sorted(alias_dict[name], key=lambda d_a: (-len(d_a[1]), d_a[0]))
# sorted by depth and name
by_depth_name = sorted(alias_dict[name], key=lambda d_a: (d_a[0], d_a[1]))
new_name = by_len_depth.pop()[1]
depth = min(imap(lambda d_a: d_a[0], alias_dict[name]))
alias_list = lmap(lambda d_a: d_a[1], by_depth_name)
alias_list.remove(new_name)
if inherit_prefix:
new_name = ' | ' * (inherit_map[name].count('-') - 1) + new_name
entry = {'Name': new_name, 'Alias': str.join(', ', alias_list),
'Depth': '%02d' % depth, 'Inherit': inherit_map.get(name, '')}
table_list.append(entry)
return table_list示例5: DiffLists
def DiffLists(oldList, newList, cmpFkt, changedFkt, isSorted = False):
(listAdded, listMissing, listChanged) = ([], [], [])
if not isSorted:
(newList, oldList) = (sorted(newList, cmpFkt), sorted(oldList, cmpFkt))
(newIter, oldIter) = (iter(newList), iter(oldList))
(new, old) = (next(newIter, None), next(oldIter, None))
while True:
if (new == None) or (old == None):
break
result = cmpFkt(new, old)
if result < 0: # new[npos] < old[opos]
listAdded.append(new)
new = next(newIter, None)
elif result > 0: # new[npos] > old[opos]
listMissing.append(old)
old = next(oldIter, None)
else: # new[npos] == old[opos] according to *active* comparison
changedFkt(listAdded, listMissing, listChanged, old, new)
(new, old) = (next(newIter, None), next(oldIter, None))
while new != None:
listAdded.append(new)
new = next(newIter, None)
while old != None:
listMissing.append(old)
old = next(oldIter, None)
return (listAdded, listMissing, listChanged)示例6: _get_sandbox_file_list
def _get_sandbox_file_list(self, task, sm_list):
# Prepare all input files
dep_list = set(ichain(imap(lambda x: x.get_dependency_list(), [task] + sm_list)))
dep_fn_list = lmap(lambda dep: resolve_path('env.%s.sh' % dep,
lmap(lambda pkg: get_path_share('', pkg=pkg), os.listdir(get_path_pkg()))), dep_list)
task_config_dict = dict_union(self._remote_event_handler.get_mon_env_dict(),
*imap(lambda x: x.get_task_dict(), [task] + sm_list))
task_config_dict.update({'GC_DEPFILES': str.join(' ', dep_list),
'GC_USERNAME': self._token.get_user_name(), 'GC_WMS_NAME': self._name})
task_config_str_list = DictFormat(escape_strings=True).format(
task_config_dict, format='export %s%s%s\n')
vn_alias_dict = dict(izip(self._remote_event_handler.get_mon_env_dict().keys(),
self._remote_event_handler.get_mon_env_dict().keys()))
vn_alias_dict.update(task.get_var_alias_map())
vn_alias_str_list = DictFormat(delimeter=' ').format(vn_alias_dict, format='%s%s%s\n')
# Resolve wildcards in task input files
def _get_task_fn_list():
for fpi in task.get_sb_in_fpi_list():
matched = glob.glob(fpi.path_abs)
if matched != []:
for match in matched:
yield match
else:
yield fpi.path_abs
return lchain([self._remote_event_handler.get_file_list(), dep_fn_list, _get_task_fn_list(), [
VirtualFile('_config.sh', sorted(task_config_str_list)),
VirtualFile('_varmap.dat', sorted(vn_alias_str_list))]])示例7: _match_entries
def _match_entries(self, container, option_list=None):
key_list = container.get_options()
if option_list is not None:
key_list = lfilter(key_list.__contains__, option_list)
def _get_entry_key_ordered(entry):
return (tuple(imap(_remove_none, _get_section_key_filtered(entry))), entry.order)
def _get_section_key_filtered(entry):
return self._get_section_key(entry.section.replace('!', '').strip())
def _remove_none(key):
if key is None:
return -1
return key
def _select_sections(entry):
return _get_section_key_filtered(entry) is not None
result = []
for key in key_list:
(entries, entries_reverse) = ([], [])
for entry in container.iter_config_entries(key, _select_sections):
if entry.section.endswith('!'):
entries_reverse.append(entry)
else:
entries.append(entry)
result.extend(sorted(entries_reverse, key=_get_entry_key_ordered, reverse=True))
result.extend(sorted(entries, key=_get_entry_key_ordered))
return result示例8: DiffLists
def DiffLists(oldList, newList, keyFun, changedFkt, isSorted = False):
(listAdded, listMissing, listChanged) = ([], [], [])
if not isSorted:
(newList, oldList) = (sorted(newList, key = keyFun), sorted(oldList, key = keyFun))
(newIter, oldIter) = (iter(newList), iter(oldList))
(new, old) = (next(newIter, None), next(oldIter, None))
while True:
if (new is None) or (old is None):
break
keyNew = keyFun(new)
keyOld = keyFun(old)
if keyNew < keyOld: # new[npos] < old[opos]
listAdded.append(new)
new = next(newIter, None)
elif keyNew > keyOld: # new[npos] > old[opos]
listMissing.append(old)
old = next(oldIter, None)
else: # new[npos] == old[opos] according to *active* comparison
changedFkt(listAdded, listMissing, listChanged, old, new)
(new, old) = (next(newIter, None), next(oldIter, None))
while new is not None:
listAdded.append(new)
new = next(newIter, None)
while old is not None:
listMissing.append(old)
old = next(oldIter, None)
return (listAdded, listMissing, listChanged)示例9: _get_workflow_graph
def _get_workflow_graph(workflow):
(graph, node_list) = _get_graph(workflow)
# Process nodes
node_str_list = []
map_node2name = {}
map_node2color = {}
for node in sorted(node_list, key=lambda x: x.__class__.__name__):
node_props = {
'label': '"%s"' % _get_node_label(node),
'fillcolor': '"%s"' % _get_node_color(node, map_node2color),
'style': '"filled"',
}
if node == workflow:
node_props['root'] = 'True'
node_prop_str = str.join('; ', imap(lambda key: '%s = %s' % (key, node_props[key]), node_props))
node_str_list.append('%s [%s];\n' % (_get_node_name(node, map_node2name), node_prop_str))
# Process edges
edge_str_list = []
for entry in sorted(graph, key=lambda x: x.__class__.__name__):
for child in sorted(set(graph[entry]), key=lambda x: x.__class__.__name__):
edge_str_list.append('%s -> %s;\n' % (_get_node_name(entry, map_node2name),
_get_node_name(child, map_node2name)))
cluster_str_list = []
dot_header = 'digraph mygraph {\nmargin=0;\nedge [len=2];\noverlap=compress;splines=True;\n'
dot_format_string_list = [dot_header] + node_str_list + cluster_str_list + edge_str_list + ['}\n']
return str.join('', dot_format_string_list)示例10: getCMSFiles
def getCMSFiles(self, blockPath):
lumiDict = {}
if self.selectedLumis: # Central lumi query
lumiDict = self.getCMSLumisImpl(blockPath)
lumiDict = QM(lumiDict, lumiDict, {})
for (fileInfo, listLumi) in self.getCMSFilesImpl(blockPath, self.onlyValid, self.selectedLumis):
if self.selectedLumis:
if not listLumi:
listLumi = lumiDict.get(fileInfo[DataProvider.URL], [])
def acceptLumi():
for (run, lumiList) in listLumi:
for lumi in lumiList:
if selectLumi((run, lumi), self.selectedLumis):
return True
if not acceptLumi():
continue
if self.includeLumi:
(listLumiExt_Run, listLumiExt_Lumi) = ([], [])
for (run, lumi_list) in sorted(listLumi):
for lumi in lumi_list:
listLumiExt_Run.append(run)
listLumiExt_Lumi.append(lumi)
fileInfo[DataProvider.Metadata] = [listLumiExt_Run, listLumiExt_Lumi]
else:
fileInfo[DataProvider.Metadata] = [list(sorted(set(map(lambda (run, lumi_list): run, listLumi))))]
yield fileInfo示例11: __init__
def __init__(self, config, job_db, task):
map_cat2jobs = {}
map_cat2desc = {}
job_config_dict = {}
vn_list = []
for jobnum in job_db.get_job_list():
if task:
job_config_dict = task.get_job_dict(jobnum)
vn_list = lfilter(self._is_not_ignored_vn, sorted(job_config_dict.keys()))
cat_key = str.join('|', imap(lambda vn: '%s=%s' % (vn, job_config_dict[vn]), vn_list))
map_cat2jobs.setdefault(cat_key, []).append(jobnum)
if cat_key not in map_cat2desc:
map_cat2desc[cat_key] = dict(imap(lambda var: (var, job_config_dict[var]), vn_list))
# Kill redundant keys from description - seed with last vn_list
common_var_dict = dict(imap(lambda var: (var, job_config_dict[var]), vn_list))
for cat_key in map_cat2desc:
for key in list(common_var_dict.keys()):
if key not in map_cat2desc[cat_key].keys():
common_var_dict.pop(key)
elif common_var_dict[key] != map_cat2desc[cat_key][key]:
common_var_dict.pop(key)
for cat_key in map_cat2desc:
for common_key in common_var_dict:
map_cat2desc[cat_key].pop(common_key)
# Generate job-category map with efficient int keys - catNum becomes the new cat_key
self._job2cat = {}
self._map_cat2desc = {}
for cat_num, cat_key in enumerate(sorted(map_cat2jobs)):
self._map_cat2desc[cat_num] = map_cat2desc[cat_key]
self._job2cat.update(dict.fromkeys(map_cat2jobs[cat_key], cat_num))示例12: get_list_difference
def get_list_difference(list_old, list_new, key_fun, on_matching_fun,
is_sorted=False, key_fun_sort=None):
(list_added, list_missing, list_matching) = ([], [], [])
if not is_sorted:
list_new = sorted(list_new, key=key_fun_sort or key_fun)
list_old = sorted(list_old, key=key_fun_sort or key_fun)
(iter_new, iter_old) = (iter(list_new), iter(list_old))
(new, old) = (next(iter_new, None), next(iter_old, None))
while True:
if (new is None) or (old is None):
break
key_new = key_fun(new)
key_old = key_fun(old)
if key_new < key_old: # new[npos] < old[opos]
list_added.append(new)
new = next(iter_new, None)
elif key_new > key_old: # new[npos] > old[opos]
list_missing.append(old)
old = next(iter_old, None)
else: # new[npos] == old[opos] according to *active* comparison
on_matching_fun(list_added, list_missing, list_matching, old, new)
(new, old) = (next(iter_new, None), next(iter_old, None))
while new is not None:
list_added.append(new)
new = next(iter_new, None)
while old is not None:
list_missing.append(old)
old = next(iter_old, None)
return (list_added, list_missing, list_matching)示例13: display_metadata
def display_metadata(dataset_list, block, metadata_key_list, metadata_list, base_header_list=None):
header_list = [(DataProvider.BlockName, 'Block')] + (base_header_list or []) + \
lzip(sorted(metadata_key_list), sorted(metadata_key_list))
for metadata in metadata_list:
metadata[DataProvider.Dataset] = block[DataProvider.Dataset]
metadata[DataProvider.BlockName] = block.get(DataProvider.BlockName)
title = get_title_update_header(dataset_list, header_list)
ConsoleTable.create(header_list, metadata_list, title=title, pivot=True)示例14: getDisplayList
def getDisplayList(aliasDict):
tableList = []
for name in aliasDict:
# sorted by length of name and depth
by_len_depth = sorted(aliasDict[name], key = lambda d_a: (-len(d_a[1]), d_a[0]))
# sorted by depth and name
by_depth_name = sorted(aliasDict[name], key = lambda d_a: (d_a[0], d_a[1]))
new_name = by_len_depth.pop()[1]
aliasList = lmap(lambda d_a: d_a[1], by_depth_name)
aliasList.remove(new_name)
entry = {'Name': new_name, 'Alias': str.join(', ', aliasList)}
if ('Multi' not in name) and ('Base' not in name):
tableList.append(entry)
return tableList示例15: _findCollision
def _findCollision(self, tName, nameDict, varDict, hashKeys, keyFmt, nameFmt = identity):
dupesDict = {}
for (key, name) in nameDict.items():
dupesDict.setdefault(nameFmt(name), []).append(keyFmt(name, key))
ask = True
for name, key_list in sorted(dupesDict.items()):
if len(key_list) > 1:
self._log.warn('Multiple %s keys are mapped to the name %s!', tName, repr(name))
for key in sorted(key_list):
self._log.warn('\t%s hash %s using:', tName, str.join('#', key))
for var, value in self._getFilteredVarDict(varDict, key, hashKeys).items():
self._log.warn('\t\t%s = %s', var, value)
if ask and not utils.getUserBool('Do you want to continue?', False):
sys.exit(os.EX_OK)
ask = False