Splits this number into cc, ndc and locally split number parts.
770847
def split number
      # Split the number into country, cc, and national part.
      country, cc, national_number = partial_split number
      
      # Split the national number into ndc and local part.
      _, ndc, *local = country.split national_number
      
      [cc, ndc, *local]
    end
1060629
def cc(self, cc):
        '''
        
        '''
        if isinstance(cc, basestring):
            cc = cc.split(',')
        self._cc = cc
526126
def split_elements(value):
    """"""
    l = [v.strip() for v in value.split(',')]
    if len(l) == 1:
        l = value.split()
    return l
538294
private String performSplitting(String source, String splitString, String indexString)
        throws TransformationOperationException {
        try {
            Integer index = Integer.parseInt(indexString);
            return source.split(splitString)[index];
        } catch (NumberFormatException e) {
            throw new TransformationOperationException("The given result index parameter is not a number");
        } catch (IndexOutOfBoundsException e) {
            throw new TransformationOperationException(
                "The split result does not have that much results for the index parameter");
        }
    }
191323
def split(self, t):
        """"""
        pt = self.point(t)
        return Line(self.start, pt), Line(pt, self.end)
93358
def splitter(iterable, chunksize=60):
    """"""
    return (iterable[0+i:chunksize+i]
            for i in range(0, len(iterable), chunksize))
929204
def split(self, bits_count):
		
		result = []
		array = WBinArray(self.__value, self.__size)

		if (len(array) % bits_count) > 0:
			array.resize(len(array) + (bits_count - (len(array) % bits_count)))

		while len(array):
			result.append(WBinArray(array[:bits_count], bits_count))
			array = array[bits_count:]
		return result
836520
def split(self):
        """"""
        self.stop()
        interval = Interval()
        interval._start_instant = self.stop_instant
        return interval
1095862
def split(nodeShape, jobShape, wallTime):
    
    return (Shape(wallTime,
                  nodeShape.memory - jobShape.memory,
                  nodeShape.cores - jobShape.cores,
                  nodeShape.disk - jobShape.disk,
                  nodeShape.preemptable),
            NodeReservation(Shape(nodeShape.wallTime - wallTime,
                                  nodeShape.memory,
                                  nodeShape.cores,
                                  nodeShape.disk,
                                  nodeShape.preemptable)))
330820
def split(self):
        """"""
        key = '%s/split' % self.key
        return self._server.query(key, method=self._server._session.put)
907309
function splitByRangeAndEnum(maybeUniverse, rangeToBeSplit) {
	var enumSet;

	// If it's an AND
	if (rangeToBeSplit instanceof is.And) {
		// recursively split each value
		var sets = rangeToBeSplit.values.map(function(setInAnd) {
			return splitByRangeAndEnum(maybeUniverse, setInAnd);
		});
		// take the intersections
		return sets.reduce(function(last, maybe) {
			return {
				range: set.intersection(last.range, maybe.range),
				enum: set.intersection(last.enum, maybe.enum)
			};
		}, {
			range: set.UNIVERSAL,
			enum: maybeUniverse
		});

	} else if (rangeToBeSplit instanceof is.In) {

		var shouldBeInValues = rangeToBeSplit.values.filter(function(value) {
			return maybeUniverse.isMember(value);
		});
		if (shouldBeInValues.length) {
			var valuesCopy = rangeToBeSplit.values.slice(0);
			canReflect.removeValues(valuesCopy, shouldBeInValues);

			return {
				enum: new is.In(shouldBeInValues),
				range: valuesCopy.length ? new is.In(valuesCopy) : set.EMPTY
			};
		} else {
			return {
				enum: set.EMPTY,
				range: rangeToBeSplit
			};
		}
	} else if (rangeToBeSplit instanceof is.NotIn) {

		// Gets the 'maybe' values in the range
		enumSet = set.intersection(maybeUniverse, rangeToBeSplit);

		// We should remove all the values within $in matching an in values.
		var rangeValues = rangeToBeSplit.values.filter(function(value) {
			return !maybeUniverse.isMember(value);
		});
		return {
			range: rangeValues.length ? new is.NotIn(rangeValues) : set.UNIVERSAL,
			enum: enumSet
		};
	} else {
		return {
			enum: set.EMPTY,
			range: rangeToBeSplit
		};
	}
}
1026815
public static int[] split(int amount, int count, int min, int max) {
        Assert.isPositive(amount, "amount必须大于0");
        Assert.isPositive(count, "count必须大于0");
        Assert.isPositive(min, "min必须大于0");
        Assert.isPositive(max, "max必须大于0");

        if (amount < count * min) {
            throw new IllegalArgumentException("参数错误，min * count 不能大于amount");
        }

        if (amount > max * count) {
            throw new IllegalArgumentException("参数错误，max * count 不能小于amount");
        }

        if (min > max) {
            throw new IllegalArgumentException("参数错误，min不能大于max");
        }

        SecureRandom secureRandom = new SecureRandom();
        int nowAmount = amount;

        int[] array = new int[count];

        for (int i = 0; i < count; i++) {
            if (i == (count - 1)) {
                array[i] = nowAmount;
            } else {
                int random = Math.abs(secureRandom.nextInt());
                int nowMax = nowAmount - ((count - i - 1) * min);
                int nowMin = nowAmount - ((count - i - 1) * max);
                //当前允许最小值
                nowMax = Math.min(nowMax, max);
                //当前允许最大值
                nowMin = Math.max(nowMin, min);
                //区间
                int mod = nowMax - nowMin;
                //当前值
                int packet;
                if (mod == 0) {
                    // 此时说明后续的红包都是最小的了
                    packet = nowMin;
                } else {
                    packet = random % mod + nowMin;
                }

                array[i] = packet;
                nowAmount -= packet;
            }
        }
        return array;
    }
1014759
def split_every(iterable, n):  # TODO: Remove this, or make it return a generator.
    
    i = iter(iterable)
    piece = list(islice(i, n))
    while piece:
        yield piece
        piece = list(islice(i, n))
331050
def separated(self, separator='-'):
        """"""
        return separator.join((part for part in self.elements() if part))
859820
def partition(N, k):
    '''

    '''
    out = [N // k] * k
    remainder = N % k
    for i in range(remainder):
        out[i] += 1
    return out
75828
def split_key(key):
    """"""
    if key == KEY_SEP:
        return ()
    key_chunks = tuple(key.strip(KEY_SEP).split(KEY_SEP))
    if key_chunks[0].startswith(KEY_SEP):
        return (key_chunks[0][len(KEY_SEP):],) + key_chunks[1:]
    else:
        return key_chunks
245319
def split_every(parts, iterable):
    
    return takewhile(bool, (list(islice(iterable, parts)) for _ in count()))