random.sample

All Samples(882) | Call(753) | Derive(0) | Import(129)

Chooses k unique random elements from a population sequence.

Returns a new list containing elements from the population while
leaving the original population unchanged.  The resulting list is
in selection order so that all sub-slices will also be valid random
samples.  This allows raffle winners (the sample) to be partitioned
into grand prize and second place winners (the subslices).

Members of the population need not be hashable or unique.  If the
population contains repeats, then each occurrence is a possible
selection in the sample.

To choose a sample in a range of integers, use xrange as an argument.
This is especially fast and space efficient for sampling from a
large population:   sample(xrange(10000000), 60)

src/w/e/Werkzeug-0.6.2/examples/shorty/utils.py Werkzeug(Download)

from os import path
from urlparse import urlparse
from random import sample, randrange
from jinja2 import Environment, FileSystemLoader
from werkzeug import Response, Local, LocalManager, cached_property
from werkzeug.routing import Map, Rule
from sqlalchemy import MetaData

def get_random_uid():
    return ''.join(sample(URL_CHARS, randrange(3, 9)))
 
 
class Pagination(object):
 
    def __init__(self, query, per_page, page, endpoint):

src/w/e/Werkzeug-0.6.2/examples/couchy/utils.py Werkzeug(Download)

from os import path
from urlparse import urlparse
from random import sample, randrange
from jinja import Environment, FileSystemLoader
from werkzeug import Response, Local, LocalManager, cached_property
from werkzeug.routing import Map, Rule

def get_random_uid():
    return ''.join(sample(URL_CHARS, randrange(3, 9)))
 
class Pagination(object):
 
    def __init__(self, results, per_page, page, endpoint):
        self.results = results

src/a/p/apythongraphlib-HEAD/src/apgl/data/ExamplesList.py apythongraphlib(Download)

'''
#TODO: Figure out use cases 
 
from random import sample
from numpy import ix_, array, zeros, loadtxt
from numpy.random import permutation
import logging

    def randomSubData(self, number):
        """Set indices of the examples to a subset""" 
        if number < 0 or number > self.__numExamples: 
            raise ValueError("Random subset size must be between 0 and " + str(self.__numExamples))
 
        self.__exampleIndices = array(sample(range(0, self.__numExamples), number))

src/a/p/apgl-0.5.8/apgl/data/ExamplesList.py apgl(Download)

'''
#TODO: Figure out use cases 
 
from random import sample
from numpy import ix_, array, zeros, loadtxt
from numpy.random import permutation
import logging

    def randomSubData(self, number):
        """Set indices of the examples to a subset""" 
        if number < 0 or number > self.__numExamples: 
            raise ValueError("Random subset size must be between 0 and " + str(self.__numExamples))
 
        self.__exampleIndices = array(sample(range(0, self.__numExamples), number))

src/b/i/BIP-0.5.2/BIP/Bayes/Samplers/MCMC.py BIP(Download)

import cython
import xmlrpclib
from multiprocessing import Pool
from random import sample
 
import numpy as np
from liveplots.xmlrpcserver import rpc_plot

                others = [x for i, x in enumerate(proptheta) if i !=c]
                dif = zeros(self.dimensions)
                for d in range(delta):
                    d1, d2 = sample(others, 2)
                    dif+=array(d1)-array(d2)
                zi = array(proptheta[c])+(ones(self.dimensions)+e)*gam*dif+eps
                #revert offlimits proposals

src/a/s/AsynCluster-0.3/doc/example.py AsynCluster(Download)

"""
 
import time, os.path
from random import sample as sampleWOR
 
import scipy as s
from scipy import stats

    def subsetIndex(self, k):
        """
        Returns a subset index for the samples in my I{X} attribute that
        correspond to the jump variance for the supplied index I{k}.
        """
        I = sampleWOR(self.Is, self.R[k])
        self.Is = s.setdiff1d(self.Is, I)

src/b/r/brian-HEAD/trunk/brian/connection.py brian(Download)

import copy
from itertools import izip
import itertools
from random import sample
import bisect
from units import *
import types

    def row_func(i):
        pyrandom.seed(initseed+int(i))
        scirandom.seed(initseed+int(i))
        k = scirandom.binomial(N, p, 1)[0]
        cur_row[:] = 0.0
        cur_row[pyrandom.sample(myrange,k)] = weight
        return cur_row

        if value.func_code.co_argcount==0: # TODO: should work with partial objects
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                W.rows[i]=sample(xrange(m),k)
                W.rows[i].sort()
                W.data[i]=[value() for _ in xrange(k)]
        elif value.func_code.co_argcount==2:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                W.rows[i]=sample(xrange(m),k)

            k=random.binomial(m,p,1)[0]
            # Not significantly faster to generate all random numbers in one pass
            # N.B.: the sample method is implemented in Python and it is not in Scipy
            W.rows[i]=sample(xrange(m),k)
            W.rows[i].sort()
            W.data[i]=[value]*k

    k=(int)(p*n)
    for j in xrange(m):
        # N.B.: the sample method is implemented in Python and it is not in Scipy
        for i in sample(xrange(n),k):
            W.rows[i].append(j)
 
    if callable(value):

        if value.func_code.co_argcount==0:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                row = sample(xrange(m),k)
                row.sort()
                yield row, [value() for _ in xrange(k)]
        elif value.func_code.co_argcount==2:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                row = sample(xrange(m),k)

    else:
        for i in xrange(n):
            k=random.binomial(m,p,1)[0]
            row = sample(xrange(m),k)
            row.sort()
            yield row, value

src/b/r/brian-HEAD/brian/connection.py brian(Download)

import copy
from itertools import izip
import itertools
from random import sample
import bisect
from units import *
import types

    def row_func(i):
        pyrandom.seed(initseed+int(i))
        scirandom.seed(initseed+int(i))
        k = scirandom.binomial(N, p, 1)[0]
        cur_row[:] = 0.0
        cur_row[pyrandom.sample(myrange,k)] = weight
        return cur_row

        if value.func_code.co_argcount==0: # TODO: should work with partial objects
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                W.rows[i]=sample(xrange(m),k)
                W.rows[i].sort()
                W.data[i]=[value() for _ in xrange(k)]
        elif value.func_code.co_argcount==2:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                W.rows[i]=sample(xrange(m),k)

            k=random.binomial(m,p,1)[0]
            # Not significantly faster to generate all random numbers in one pass
            # N.B.: the sample method is implemented in Python and it is not in Scipy
            W.rows[i]=sample(xrange(m),k)
            W.rows[i].sort()
            W.data[i]=[value]*k

    k=(int)(p*n)
    for j in xrange(m):
        # N.B.: the sample method is implemented in Python and it is not in Scipy
        for i in sample(xrange(n),k):
            W.rows[i].append(j)
 
    if callable(value):

        if value.func_code.co_argcount==0:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                row = sample(xrange(m),k)
                row.sort()
                yield row, [value() for _ in xrange(k)]
        elif value.func_code.co_argcount==2:
            for i in xrange(n):
                k=random.binomial(m,p,1)[0]
                row = sample(xrange(m),k)

    else:
        for i in xrange(n):
            k=random.binomial(m,p,1)[0]
            row = sample(xrange(m),k)
            row.sort()
            yield row, value

src/b/r/brian-1.2.1/brian/connection.py brian(Download)

import copy
from itertools import izip
import itertools
from random import sample
import bisect
from units import *
import types

    def row_func(i):
        pyrandom.seed(initseed + int(i))
        scirandom.seed(initseed + int(i))
        k = scirandom.binomial(N, p, 1)[0]
        cur_row[:] = 0.0
        cur_row[pyrandom.sample(myrange, k)] = weight
        return cur_row

        if value.func_code.co_argcount == 0: # TODO: should work with partial objects
            for i in xrange(n):
                k = random.binomial(m, p, 1)[0]
                W.rows[i] = sample(xrange(m), k)
                W.rows[i].sort()
                W.data[i] = [value() for _ in xrange(k)]
        elif value.func_code.co_argcount == 2:

                log_debug('connections', 'Cannot build the connection matrix by rows')
                for i in xrange(n):
                    k = random.binomial(m, p, 1)[0]
                    W.rows[i] = sample(xrange(m), k)
                    W.rows[i].sort()
                    W.data[i] = [value(i, j) for j in W.rows[i]]
            else:
                for i in xrange(n):
                    k = random.binomial(m, p, 1)[0]
                    W.rows[i] = sample(xrange(m), k)

            k = random.binomial(m, p, 1)[0]
            # Not significantly faster to generate all random numbers in one pass
            # N.B.: the sample method is implemented in Python and it is not in Scipy
            W.rows[i] = sample(xrange(m), k)
            W.rows[i].sort()
            W.data[i] = [value] * k

    k = (int)(p * n)
    for j in xrange(m):
        # N.B.: the sample method is implemented in Python and it is not in Scipy
        for i in sample(xrange(n), k):
            W.rows[i].append(j)
 
    if callable(value):

src/p/y/PyBrain-0.3/pybrain/structure/evolvables/maskedparameters.py PyBrain(Download)

__author__ = 'Tom Schaul, tom@idsia.ch'
 
from scipy import zeros, randn
from random import random, sample, gauss
 
from topology import TopologyEvolvable

                onbits.append(i)
        over = len(onbits) - self.maxComplexity
        if over > 0:
            for i in sample(onbits, over):
                self.mask[i] = False
        self.maskableParams = randn(self.pcontainer.paramdim)*self.stdParams
        self._applyMask()

1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Next