Python builtins.list方法代码示例

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def standardize(dataframe):
    """Scales numerical columns using their means and standard deviation to get
    z-scores: the mean of each numerical column becomes 0, and the standard
    deviation becomes 1. This can help the model converge during training.

    Args:
      dataframe: Pandas dataframe

    Returns:
      Input dataframe with the numerical columns scaled to z-scores
    """
    dtypes = list(zip(dataframe.dtypes.index, map(str, dataframe.dtypes)))
    # Normalize numeric columns.
    for column, dtype in dtypes:
        if dtype == 'float32':
            dataframe[column] -= dataframe[column].mean()
            dataframe[column] /= dataframe[column].std()
    return dataframe 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def __init__(self, space: StateSpace, typ: Type, smtvar: object):
        self.val_pytype = normalize_pytype(type_arg_of(typ, 1))
        self.smt_val_sort = type_to_smt_sort(self.val_pytype)
        SmtDictOrSet.__init__(self, space, typ, smtvar)
        self.val_ch_type = crosshair_type_for_python_type(self.val_pytype)
        arr_var = self._arr()
        len_var = self._len()
        self.val_missing_checker = arr_var.sort().range().recognizer(0)
        self.val_missing_constructor = arr_var.sort().range().constructor(0)
        self.val_constructor = arr_var.sort().range().constructor(1)
        self.val_accessor = arr_var.sort().range().accessor(1, 0)
        self.empty = z3.K(arr_var.sort().domain(),
                          self.val_missing_constructor())
        self._iter_cache = []
        space.add((arr_var == self.empty) == (len_var == 0))
        def list_can_be_iterated():
            list(self)
            return True
        space.defer_assumption('dict iteration is consistent with items', list_can_be_iterated) 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def _decode_header(header):
        """Decodes an email header and returns it as a string. Any  parts of
        the header that cannot be decoded are simply ignored.
        """
        parts = list()
        try:
            decoded_header = email.header.decode_header(header)
        except (ValueError, email.header.HeaderParseError):
            return

        for value, encoding in decoded_header:
            if encoding:
                try:
                    parts.append(value.decode(encoding, "ignore"))
                except (LookupError, UnicodeError, AssertionError):
                    continue
            else:
                try:
                    parts.append(value.decode("utf-8", "ignore"))
                except AttributeError:
                    parts.append(value)
        return "".join(parts) 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def tokenize(input, escapables={"'", '"', '\\'} | {item for item in string.whitespace} - {' '}):
    """Yield each token belonging to the windbg format in `input` that would need to be escaped using the specified `escapables`.

    If the set `escapables` is defined, then use it as the list of characters to tokenize.
    """
    result, iterable = '', iter(input)
    try:
        while True:
            char = six.next(iterable)
            if operator.contains(escapables, char):
                if result:
                    yield result
                yield char
                result = ''

            else:
                result += char
            continue

    except StopIteration:
        if result:
            yield result
        return
    return 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def collect_stdlib_distributions():
    """Yield a conventional spec and the names of all top_level standard library modules."""
    distribution_spec = 'Python==%d.%d.%d' % sys.version_info[:3]
    stdlib_path = sysconfig.get_python_lib(standard_lib=True)
    distribution_top_level = [name for _, name, _ in pkgutil.iter_modules(path=[stdlib_path])]
    distribution_top_level += list(sys.builtin_module_names)
    yield distribution_spec, distribution_top_level 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def pytest_addoption(parser):
    group = parser.getgroup('nodev')
    group.addoption(
        '--candidates-from-stdlib', action='store_true',
        help="Collects candidates form the Python standard library.")
    group.addoption(
        '--candidates-from-all', action='store_true',
        help="Collects candidates form the Python standard library and all installed packages. "
             "Disabled by default, see the docs.")
    group.addoption(
        '--candidates-from-specs', default=[], nargs='+',
        help="Collects candidates from installed packages. Space separated list of `pip` specs.")
    group.addoption(
        '--candidates-from-modules', default=[], nargs='+',
        help="Collects candidates from installed modules. Space separated list of module names.")
    group.addoption(
        '--candidates-includes', nargs='+',
        help="Space separated list of regexs matching full object names to include, "
             "defaults to include all objects collected via `--candidates-from-*`.")
    group.addoption(
        '--candidates-excludes', default=[], nargs='+',
        help="Space separated list of regexs matching full object names to exclude.")
    group.addoption(
        '--candidates-predicate', default='builtins:callable',
        help="Full name of the predicate passed to `inspect.getmembers`, "
             "defaults to `builtins.callable`.")
    group.addoption('--candidates-fail', action='store_true', help="Show candidates failures.") 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def pytest_pycollect_makeitem(collector, name, obj):
    candidate_marker = getattr(obj, 'candidate', None)
    if candidate_marker and getattr(candidate_marker, 'args', []):
        candidate_name = candidate_marker.args[0]

        def wrapper(candidate, monkeypatch, *args, **kwargs):
            if '.' in candidate_name:
                monkeypatch.setattr(candidate_name, candidate, raising=False)
            else:
                monkeypatch.setattr(inspect.getmodule(obj), candidate_name, candidate, raising=False)
            return obj(*args, **kwargs)

        wrapper.__dict__ = obj.__dict__
        return list(collector._genfunctions(name, wrapper)) 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def test_collect_stdlib_distributions():
    stdlib_distributions = list(collect.collect_stdlib_distributions())
    assert len(stdlib_distributions) == 1
    _, module_names = stdlib_distributions[0]
    assert len(module_names) > 10 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def test_collect_distributions():
    distributions = list(collect.collect_distributions(['pytest-nodev']))
    assert len(distributions) == 1
    _, module_names = distributions[0]
    assert len(module_names) == 1
    assert len(list(collect.collect_distributions(['non_existent_distribution']))) == 0 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def test_import_distributions():
    distributions = [('pytest-nodev', ['pytest_nodev'])]
    module_names = list(collect.import_distributions(distributions))
    assert module_names == ['pytest_nodev']

    distributions = [('pytest-nodev', ['non_existent_module'])]
    module_names = list(collect.import_distributions(distributions))
    assert module_names == [] 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def test_generate_module_objects():
    expected_item = ('generate_module_objects', collect.generate_module_objects)
    assert expected_item in list(collect.generate_module_objects(collect)) 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def test_generate_objects_from_modules():
    import re
    modules = {'pytest_nodev.collection': collect, 're': re}
    include_patterns = ['pytest_nodev.collection:generate_objects_from_modules']
    objs = collect.generate_objects_from_modules(
        modules, include_patterns, module_blacklist_pattern='re')
    assert len(list(objs)) == 1 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def columnar_data_chunks(self, data_path, sa_table, chunk_size):
        """A generator function that returns chunk_size rows (or whatever is left
        at the end of the file) in columnar format
        This function also performs conversion from string to python datatype based on the given
        SQLAlchemy schema.
        """

        # An array of functions corresponding to the CSV columns that take a string and return the
        # corresponding Python datatype
        type_converters = self.table_to_conversion_funcs(sa_table)
        with self.get_csv_reader(data_path) as reader:
            num_cols = len(sa_table.columns)
            col_indices = range(num_cols)
            data = [list() for i in range(num_cols)]

            # Read in CSV and store it by column (makes passing to Arrow easier)
            for row in reader:
                # read a row
                for i in col_indices:
                    value = row[i]
                    py_type = type_converters[i]

                    value = self._convert_to_type(value, py_type)
                    data[i].append(value)

                if len(data[0]) == chunk_size:
                    yield data
                    self._clear_and_collect(data)

            # Number of rows in file is not necessarily divisible by chunk_size
            # So make sure there isn't any lingering data to process
            if data[0]:
                yield data
                self._clear_and_collect(data) 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def assign(item, assignment, **kwargs):
    key = kwargs.get('assign')
    value = next(assignment) if kwargs.get('one') else list(assignment)
    merged = merge([item, {key: value}])
    yield DotDict(merged) if kwargs.get('dictize') else merged 

# 需要导入模块: import builtins [as 别名]
# 或者: from builtins import list [as 别名]
def __init__(self, *args, length=None, graph=None, name=None, dependencies=None, **kwargs):
        self.args = args
        self.kwargs = kwargs
        self.length = length
        self.graph = Graph.get_active_graph(graph)
        # Choose a name for the operation and add the operation to the graph
        self._name = None
        self.name = name or uuid.uuid4().hex
        # Get a list of all dependencies relevant to this operation
        self.dependencies = [] if dependencies is None else dependencies
        self.dependencies.extend(self.graph.dependencies)
        # Get the stack context so we can report where the operation was defined
        self._stack = traceback.extract_stack()