我们从Python开源项目中，提取了以下49个代码示例，用于说明如何使用builtins.all()。
def load(file): """ Wrapper around cPickle.load which accepts either a file-like object or a filename. Note that the NumPy binary format is not based on pickle/cPickle anymore. For details on the preferred way of loading and saving files, see `load` and `save`. See Also -------- load, save """ if isinstance(file, type("")): file = open(file, "rb") return pickle.load(file) # These are all essentially abbreviations # These might wind up in a special abbreviations module
def __init__(self): # The tree, which should be built. self._tree = [] # List of all open constructs self._open_blocks = [] # Nodes to which the open blocks have to be appended when closed self._path = [] # Nr. of open blocks when file was opened. Used for checking whether all # blocks have been closed, when file processing finishes. self._nr_prev_blocks = [] # Current node, to which content should be added self._curnode = self._tree # Current file self._curfile = None
def __init__(self, env=None): # Global scope self._globals = env if env is not None else {} # Local scope(s) self._locals = None self._locals_stack = [] # Variables which are references to entries in global scope self._globalrefs = None self._globalrefs_stack = [] # Current scope (globals + locals in all embedding and in current scope) self._scope = self._globals # Turn on restricted mode self._restrict_builtins()
def decorate(self, pos, data, is_first=True): # We can use the tree position as table ID self._table.register(pos) row = self._table.get_row(pos) # We use parent's decorate() method to give the name column a tree # structure. But we also need the original update() method so we can # apply new data to the widget. This is dirty but it works. update_method = row.name.update decowidget = super().decorate(pos, row.name, is_first=is_first) decowidget.update = update_method row.replace('name', decowidget) # Wrap the whole row in a FileItemWidget with keymapping. This also # applies all the other values besides the name (size, progress, etc). file_widget = self._filewidgetcls(data, row) node_id = (data['tid'], data['id']) self._widgets[node_id] = file_widget return file_widget
def all_children(self, pos): """Yield (position, widget) tuples of all sub-nodes (leaves and parents)""" ft = self._filetree lb = self._listbox def recurse(subpos): widget = lb.body[subpos] if ft.is_leaf(subpos): yield (subpos, widget) else: # Yield sub-parent nodes, but not the starting node that was # passed to us if subpos != pos: yield (subpos, widget) new_subpos = ft.first_child_position(subpos) while new_subpos is not None: yield from recurse(new_subpos) new_subpos = ft.next_sibling_position(new_subpos) yield from recurse(pos)
def extractall(patt, filename, tag=0, conv=None, encoding='utf-8'): """Extract all values from the capturing group ``tag`` of a matching regex ``patt`` in the file ``filename``. :arg patt: The regex pattern to search. Any standard Python `regular expression <https://docs.python.org/3.6/library/re.html#regular-expression-syntax>`_ is accepted. :arg filename: The name of the file to examine. :arg encoding: The name of the encoding used to decode the file. :arg tag: The regex capturing group to be extracted. Group ``0`` refers always to the whole match. Since the file is processed line by line, this means that group ``0`` returns the whole line that was matched. :arg conv: A callable that takes a single argument and returns a new value. If provided, it will be used to convert the extracted values before returning them. :returns: A list of the extracted values from the matched regex. :raises reframe.core.exceptions.SanityError: In case of errors. """ return list(evaluate(x) for x in extractiter(patt, filename, tag, conv, encoding))
def avg(iterable): """Return the average of all the elements of ``iterable``.""" # We walk over the iterable manually in case this is a generator total = 0 num_vals = None for num_vals, val in builtins.enumerate(iterable, start=1): total += val if num_vals is None: raise SanityError('attempt to get average on an empty container') return total / num_vals # Other utility functions
def _validate_axis(axis, ndim, argname): try: axis = [operator.index(axis)] except TypeError: axis = list(axis) axis = [a + ndim if a < 0 else a for a in axis] if not builtins.all(0 <= a < ndim for a in axis): raise ValueError('invalid axis for this array in `%s` argument' % argname) if len(set(axis)) != len(axis): raise ValueError('repeated axis in `%s` argument' % argname) return axis
def _maketup(descr, val): dt = dtype(descr) # Place val in all scalar tuples: fields = dt.fields if fields is None: return val else: res = [_maketup(fields[name][0], val) for name in dt.names] return tuple(res)
def identity(n, dtype=None): """ Return the identity array. The identity array is a square array with ones on the main diagonal. Parameters ---------- n : int Number of rows (and columns) in `n` x `n` output. dtype : data-type, optional Data-type of the output. Defaults to ``float``. Returns ------- out : ndarray `n` x `n` array with its main diagonal set to one, and all other elements 0. Examples -------- >>> np.identity(3) array([[ 1., 0., 0.], [ 0., 1., 0.], [ 0., 0., 1.]]) """ from numpy import eye return eye(n, dtype=dtype)
def array_equal(a1, a2): """ True if two arrays have the same shape and elements, False otherwise. Parameters ---------- a1, a2 : array_like Input arrays. Returns ------- b : bool Returns True if the arrays are equal. See Also -------- allclose: Returns True if two arrays are element-wise equal within a tolerance. array_equiv: Returns True if input arrays are shape consistent and all elements equal. Examples -------- >>> np.array_equal([1, 2], [1, 2]) True >>> np.array_equal(np.array([1, 2]), np.array([1, 2])) True >>> np.array_equal([1, 2], [1, 2, 3]) False >>> np.array_equal([1, 2], [1, 4]) False """ try: a1, a2 = asarray(a1), asarray(a2) except: return False if a1.shape != a2.shape: return False return bool(asarray(a1 == a2).all())
def widgets(self): """Yield all file and directory widgets in this tree""" yield from self._widgets.values()
def focused_file_ids(self): """File IDs of the focused files in a tuple""" focused = self.focused_widget if focused is not None: # The focused widget in the list can be a file or a directory. If # it's a directory, the 'file_id' property returns the IDs of all # the contained files recursively. fid = focused.file_id return tuple(fid) if isinstance(fid, (abc.Sequence, abc.Set)) else (fid,)
def all(iterable): """ Returns True if all elements of the iterable are true. """ for element in iterable: if not element: return False return True
def all(iterable): """Replacement for the built-in :func:`all() <python:all>` function.""" return builtins.all(iterable)
def and_(a, b): """Deferrable version of the :keyword:`and` operator. :returns: ``a and b``.""" return builtins.all([a, b])
def findall(patt, filename, encoding='utf-8'): """Get all matches of regex ``patt`` in ``filename``. :arg patt: The regex pattern to search. Any standard Python `regular expression <https://docs.python.org/3.6/library/re.html#regular-expression-syntax>`_ is accepted. :arg filename: The name of the file to examine. :arg encoding: The name of the encoding used to decode the file. :returns: A list of raw `regex match objects <https://docs.python.org/3.6/library/re.html#match-objects>`_. :raises reframe.core.exceptions.SanityError: In case an :class:`OSError` is raised while processing ``filename``. """ return list(evaluate(x) for x in finditer(patt, filename, encoding))
def test_chain(self): list1 = ['A', 'B', 'C'] list2 = ['D', 'E', 'F'] chain1 = evaluate(chain(make_deferrable(list1), list2)) chain2 = itertools.chain(list1, list2) self.assertTrue(builtins.all( (a == b for a, b in builtins.zip(chain1, chain2))))
def geterr(): """ Get the current way of handling floating-point errors. Returns ------- res : dict A dictionary with keys "divide", "over", "under", and "invalid", whose values are from the strings "ignore", "print", "log", "warn", "raise", and "call". The keys represent possible floating-point exceptions, and the values define how these exceptions are handled. See Also -------- geterrcall, seterr, seterrcall Notes ----- For complete documentation of the types of floating-point exceptions and treatment options, see `seterr`. Examples -------- >>> np.geterr() {'over': 'warn', 'divide': 'warn', 'invalid': 'warn', 'under': 'ignore'} >>> np.arange(3.) / np.arange(3.) array([ NaN, 1., 1.]) >>> oldsettings = np.seterr(all='warn', over='raise') >>> np.geterr() {'over': 'raise', 'divide': 'warn', 'invalid': 'warn', 'under': 'warn'} >>> np.arange(3.) / np.arange(3.) __main__:1: RuntimeWarning: invalid value encountered in divide array([ NaN, 1., 1.]) """ maskvalue = umath.geterrobj()[1] mask = 7 res = {} val = (maskvalue >> SHIFT_DIVIDEBYZERO) & mask res['divide'] = _errdict_rev[val] val = (maskvalue >> SHIFT_OVERFLOW) & mask res['over'] = _errdict_rev[val] val = (maskvalue >> SHIFT_UNDERFLOW) & mask res['under'] = _errdict_rev[val] val = (maskvalue >> SHIFT_INVALID) & mask res['invalid'] = _errdict_rev[val] return res
def geterrcall(): """ Return the current callback function used on floating-point errors. When the error handling for a floating-point error (one of "divide", "over", "under", or "invalid") is set to 'call' or 'log', the function that is called or the log instance that is written to is returned by `geterrcall`. This function or log instance has been set with `seterrcall`. Returns ------- errobj : callable, log instance or None The current error handler. If no handler was set through `seterrcall`, ``None`` is returned. See Also -------- seterrcall, seterr, geterr Notes ----- For complete documentation of the types of floating-point exceptions and treatment options, see `seterr`. Examples -------- >>> np.geterrcall() # we did not yet set a handler, returns None >>> oldsettings = np.seterr(all='call') >>> def err_handler(type, flag): ... print("Floating point error (%s), with flag %s" % (type, flag)) >>> oldhandler = np.seterrcall(err_handler) >>> np.array([1, 2, 3]) / 0.0 Floating point error (divide by zero), with flag 1 array([ Inf, Inf, Inf]) >>> cur_handler = np.geterrcall() >>> cur_handler is err_handler True """ return umath.geterrobj()[2]
def _set_mark(self, mark, toggle=False, all=False): if toggle: focused = self.focused_widget if focused is not None: mark = not focused.is_marked def get_widget(pos): return self._listbox.body[pos] def mark_leaves(pos, mark): get_widget(pos).is_marked = mark for subpos,widget in self.all_children(pos): if widget.nodetype == 'leaf': widget.is_marked = mark if mark: self._marked.add(widget) else: self._marked.discard(widget) elif widget.nodetype == 'parent': if pos != subpos: # Avoid infinite recursion mark_leaves(subpos, mark) if all: # Top ancestor node positions are (0,), (1,), (3,) etc for pos in self._filetree.positions(): if len(pos) == 1: mark_leaves(pos, mark) else: mark_leaves(self._listbox.focus_position, mark) assert builtins.all(m.nodetype == 'leaf' for m in self._marked) # A parent node is marked only if all its children are marked. To check # that, we walk through every ancestor up to the top and check all its # children. There is no need to check the children of other parent # nodes (uncles, great uncles, etc) because they should already be # marked properly from previous runs. def all_children_marked(pos): marked = True childpos = self._filetree.first_child_position(pos) while childpos is not None: marked = marked and get_widget(childpos).is_marked childpos = self._filetree.next_sibling_position(childpos) return marked parpos = self._filetree.parent_position(self._listbox.focus_position) while parpos is not None: parwidget = get_widget(parpos) parwidget.is_marked = all_children_marked(parpos) parpos = self._filetree.parent_position(parpos)
