10 examples of 'python split string every n characters' in Python

113
def split(string, char):
114
    """ Split a string with a char and return always two parts"""
115
    string_list = string.split(char)
116
    if len(string_list) == 1:
117
        return None, None
118
    return char.join(string_list[:-1]), string_list[-1]

7
def split_string(s, n):
8
	return [s[i*n:i*n+n] for i, j in enumerate(s[::n])]

65
def split(self, string):
66
    return self._name + ".split(\"" + string + "\")"

143
def _split_basic(string):
144
    """
145
    Split a string into a list of tuples of the form (key, modifier_fn,
146
    explode) where modifier_fn is a function that applies the appropriate
147
    modification to the variable.
148
    """
149
    tuples = []
150
    for word in string.split(','):
151
        # Attempt to split on colon
152
        parts = word.split(':', 2)
153
        key, modifier_fn, explode = parts[0], _identity, False
154
        if len(parts) > 1:
155
            modifier_fn = functools.partial(
156
                _truncate, num_chars=int(parts[1]))
157
        if word[len(word) - 1] == '*':
158
            key = word[:len(word) - 1]
159
            explode = True
160
        tuples.append((key, modifier_fn, explode))
161
    return tuples

476
def _split(self, string):
477
    start_index, max_index = self._find_variable(string)
478
    self.start = start_index
479
    self._open_curly = 1
480
    self._state = self._variable_state
481
    self._variable_chars = [string[start_index], '{']
482
    self._list_variable_index_chars = []
483
    self._string = string
484
    start_index += 2
485
    for index, char in enumerate(string[start_index:]):
486
        index += start_index  # Giving start to enumerate only in Py 2.6+
487
        try:
488
            self._state(char, index)
489
        except StopIteration:
490
            return
491
        if index  == max_index and not self._scanning_list_variable_index():
492
            return

138
def test_split_string_after_returns_original_string_when_chunksize_equals_string_size_plus_one():
139
    str_ = 'foobar2000' * 2
140
    splitter = split_string_after(str_, len(str_) + 1)
141
    split = [chunk for chunk in splitter]
142
    assert [str_] == split

176
@pytest.mark.parametrize('s, maxsplit',
177
                         [("foo bar baz", 1), ("  foo bar baz  ", 0)],
178
                         ids=repr)
179
def test_str_split_maxsplit(self, s, maxsplit):
180
    """Test if the behavior matches str.split with given maxsplit."""
181
    actual = split.simple_split(s, maxsplit=maxsplit)
182
    expected = s.rstrip().split(maxsplit=maxsplit)
183
    assert actual == expected

126
def split_string(input_string):
127
    '''Split a string to a list and strip it
128
    :param input_string: A string that contains semicolons as separators.
129
    '''
130
    string_splitted = input_string.split(';')
131
    # Remove whitespace at the beginning and end of each string
132
    strings_striped = [string.strip() for string in string_splitted]
133
    return strings_striped

2
def split_every(n, s):
3
    return [ s[i:i+n] for i in xrange(0, len(s), n) ]

1287
def split(a, sep=None, maxsplit=None):
1288
    """
1289
    For each element in `a`, return a list of the words in the
1290
    string, using `sep` as the delimiter string.
1291
1292
    Calls `str.split` element-wise.
1293
1294
    Parameters
1295
    ----------
1296
    a : array_like of str or unicode
1297
1298
    sep : str or unicode, optional
1299
       If `sep` is not specified or `None`, any whitespace string is a
1300
       separator.
1301
1302
    maxsplit : int, optional
1303
        If `maxsplit` is given, at most `maxsplit` splits are done.
1304
1305
    Returns
1306
    -------
1307
    out : ndarray
1308
        Array of list objects
1309
1310
    See also
1311
    --------
1312
    str.split, rsplit
1313
1314
    """
1315
    # This will return an array of lists of different sizes, so we
1316
    # leave it as an object array
1317
    return _vec_string(
1318
        a, object_, 'split', [sep] + _clean_args(maxsplit))