在 python 中重复 function 类似于 R

Question

The question is: Is there a repeat function in python similar to R rep function? R have a powerful rep function as follows:

rep(x, times = 1, length.out = NA, each = 1)

• x: a vector

• times: an integer-valued vector giving the (non-negative) number of times to repeat each element if of length length(x), or to repeat the whole vector if of length 1. Negative or NA values are an error. A double vector is accepted, other inputs being coerced to an integer or double vector.

• length.out: non-negative integer. The desired length of the output vector. Other inputs will be coerced to a double vector and the first element taken. Ignored if NA or invalid.

• each: non-negative integer. Each element of x is repeated each times. Other inputs will be coerced to an integer or double vector and the first element taken. Treated as 1 if NA or invalid.

Some examples are as follows:

R code
> letters
 [1] "a" "b" "c" "d" "e" "f" "g" "h" "i" "j" "k" "l" "m" "n" "o" "p" "q" "r" "s" "t" "u" "v"
[23] "w" "x" "y" "z"
#Example 1
> rep(letters[1:3],times=c(1,2,4))
[1] "a" "b" "b" "c" "c" "c" "c"
#Example 2
> rep(letters[1:3],each=2,len=15)
 [1] "a" "a" "b" "b" "c" "c" "a" "a" "b" "b" "c" "c" "a" "a" "b"
#repeat a:c each element 2 until length be 15
#Example 3
> rep(letters[1:3],each=3,times=2)
 [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "a" "a" "a" "b" "b" "b" "c" "c" "c"
#repeat a:c each element 3  and repeat this 2 times
#Example 4
> rep(letters[c(TRUE,FALSE)],each=2)
 [1] "a" "a" "c" "c" "e" "e" "g" "g" "i" "i" "k" "k" "m" "m" "o" "o" "q" "q" "s" "s" "u" "u"
[23] "w" "w" "y" "y"
#Example 5
> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2)
 [1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
#Example 6
> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2,len=25)
[1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
[23] "a" "a" "c"

In python I just found functions that repeat each element of an array, that is, repeat elements of an array 4 times.

Python
import numpy as np
import string
letters =string.ascii_lowercase
letters =list(letters)
print(np.repeat(letters, 2))
['a' 'a' 'b' 'b' 'c' 'c' 'd' 'd' 'e' 'e' 'f' 'f' 'g' 'g' 'h' 'h' 'i' 'i'
 'j' 'j' 'k' 'k' 'l' 'l' 'm' 'm' 'n' 'n' 'o' 'o' 'p' 'p' 'q' 'q' 'r' 'r'
 's' 's' 't' 't' 'u' 'u' 'v' 'v' 'w' 'w' 'x' 'x' 'y' 'y' 'z' 'z']
 
print(np.repeat(['a','b'], [1,2]))
['a' 'b' 'b']

Is it possible to use numpy.repeat like rep function in R(see example 4,5,6)? if not? Is there a function that does the same as R's rep? If not how to create one?

EDIT: I can make all examples as follows (still working to make a flexible function to do this):

    #Python code
    import numpy, itertools, string
    letters =string.ascii_lowercase
    letters =list(letters)
    #Example 1
    #> rep(letters[1:3],times=c(1,2,4))
    #[1] "a" "b" "b" "c" "c" "c" "c"
    lttrs=[letters[i] for i in [0,1,2]]
    print(lttrs)
    # ['a', 'b', 'c']
    rd=numpy.repeat(lttrs,[1,2,4])
    print(rd)
    #['a' 'b' 'b' 'c' 'c' 'c' 'c']
    ########################################################
    
    
    #Example 2
    #> rep(letters[1:3],each=2,len=15)
    # [1] "a" "a" "b" "b" "c" "c" "a" "a" "b" "b" "c" "c" "a" "a" "b"
    #repeat a:c each element 2 until length be 15
    
    input=itertools.cycle(numpy.repeat(lttrs, 2))
    rd=list(itertools.islice(itertools.cycle(input), 15))
    print(rd)
    #['a', 'a', 'b', 'b', 'c', 'c', 'a', 'a', 'b', 'b', 'c', 'c', 'a', 'a', 'b']
    ######################################################
    
    
    #Example 3
    #> rep(letters[1:3],each=3,times=2)
    # [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "a" "a" "a" "b" "b" "b" "c" "c" "c"
    #repeat a:c each element 3  and repeat this 2 times
    
    result_numpy=numpy.repeat(lttrs,3)
    result_itertools=list(itertools.repeat(result_numpy,2))
    rd= list(itertools.chain(*list(result_itertools)))
    print(rd)
    
    # ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c']
    ######################################################
    
    
    #Example 4
    #> rep(letters[c(TRUE,FALSE)],each=2)
    # [1] "a" "a" "c" "c" "e" "e" "g" "g" "i" "i" "k" "k" "m" "m" "o" "o" "q" "q" "s" "s" "u" "u"
    #[23] "w" "w" "y" "y"
    
    def which_is_true(indexTF):
        return [i for i, x in enumerate(indexTF) if x]
    
      
    def index_TF(x,index=[True]):
        if(len(index)<len(x)):
            index_final=list(itertools.islice(itertools.cycle(index), len(x)))
        else:
            index_final=index[:len(x)]
        return [x[i] for i in list(which_is_true(index_final))]
    
    
    lttrs_TF=index_TF(letters,[True,False])
    input=numpy.repeat(lttrs_TF, 2)
    rd=list(input)
    print(rd)
    #['a', 'a', 'c', 'c', 'e', 'e', 'g', 'g', 'i', 'i', 'k', 'k', 'm', 'm', 'o', 'o', 'q', 'q', 's', 's', 'u', 'u', 'w', 'w', 'y', 'y']
    
    
    #####################################
    #Example 5
    #> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2)
    # [1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
    lttrs_TF=index_TF(letters,[True,False,True,False,False])
    input=numpy.repeat(lttrs_TF, 2)
    rd=list(input)
    print(rd)
    
    #['a', 'a', 'c', 'c', 'f', 'f', 'h', 'h', 'k', 'k', 'm', 'm', 'p', 'p', 'r', 'r', 'u', 'u', 'w', 'w', 'z', 'z']
    
    #Example 6
    #> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2,len=25)
    #[1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
    #[23] "a" "a" "c"
    lttrs_TF=index_TF(letters,[True,False,True,False,False])
    input=itertools.cycle(numpy.repeat(lttrs_TF, 2))
    output=list(itertools.islice(itertools.cycle(input), 25))
    print(output)
    #  ['a', 'a', 'c', 'c', 'f', 'f', 'h', 'h', 'k', 'k', 'm', 'm', 'p', 'p', 'r', 'r', 'u', 'u', 'w', 'w', 'z', 'z', 'a', 'a', 'c']

Answer 1

Its not quite clear what you want to achieve. You can use slicing to get an equivalent output in numpy like Example 4, or you can use indexing with a mask to get your desired results (Example 5). There is not an exact equivalent function in python.

# Example 4
import numpy as np
import string
letters =string.ascii_lowercase
letters =list(letters)

print(np.repeat(letters[::2],2))

['a' 'a' 'c' 'c' 'e' 'e' 'g' 'g' 'i' 'i' 'k' 'k' 'm' 'm' 'o' 'o' 'q' 'q'
 's' 's' 'u' 'u' 'w' 'w' 'y' 'y']

# Example 5
import numpy as np
import string
letters =string.ascii_lowercase  
letters = np.array(list(letters))

indicies = [(0,2,5,7,10,12,15,17,20,22,25)]

print(np.repeat(letters[indicies],2))

['a' 'a' 'c' 'c' 'f' 'f' 'h' 'h' 'k' 'k' 'm' 'm' 'p' 'p' 'r' 'r' 'u' 'u'
 'w' 'w' 'z' 'z']

Answer 2

import numpy, itertools, string
letters =string.ascii_lowercase
letters =list(letters)
lttrs=[letters[i] for i in [0,1,2]]
print(lttrs)
def which_is_true(indexTF):
    return [i for i, x in enumerate(indexTF) if x]

  
def index_TF(x,index=[True]):
    if(len(index)<len(x)):
        index_final=list(itertools.islice(itertools.cycle(index), len(x)))
    else:
        index_final=index[:len(x)]
    return [x[i] for i in list(which_is_true(index_final))]


def rep_times(x, times=1,each=1):
    result_numpy=numpy.repeat(x,each)
    result_itertools=list(itertools.repeat(result_numpy,times))
    return list(itertools.chain(*list(result_itertools)))

def rep_lengthout(x, lengthout=None,each=1):
    
    input=itertools.cycle(numpy.repeat(x, each))
    if lengthout:
        output=list(itertools.islice(itertools.cycle(input), lengthout))
    else:
        lengthout_all=len(x)*each
        output=list(itertools.islice(itertools.cycle(input), lengthout_all))
    return output


def rep_times_TF(x, times = 1, each = 1,index=[True]):
    x_index_TrueFalse=index_TF(x,index=index)
    ret_v=rep_times(x_index_TrueFalse, times=times,each=each)
    return(list(ret_v))

def rep_lengthout_TF(x, lengthout=None,each=1,index=[True]):
    x_index_TrueFalse=index_TF(x,index=index)
    output=rep_lengthout(x_index_TrueFalse, lengthout=lengthout,each=each)
    return output
  
rep_times_TF(lttrs, times = 2, each = 2,index=[True,False])
rep_lengthout_TF(lttrs, lengthout=None , each = 2,index=[True,False])
###########################################

#Example 1
#> rep(letters[1:3],times=c(1,2,4))
#[1] "a" "b" "b" "c" "c" "c" "c"
rd=numpy.repeat(lttrs,[1,2,4])
print(rd)
rep_times_TF(lttrs, times = 1, each = [1,2,4],index=[True])
##################################################


#Example 2
#> rep(letters[1:3],each=2,len=15)
# [1] "a" "a" "b" "b" "c" "c" "a" "a" "b" "b" "c" "c" "a" "a" "b"
#repeat a:c each element 2 until length be 15

input=itertools.cycle(numpy.repeat(lttrs, 2))
rd=list(itertools.islice(itertools.cycle(input), 15))
print(rd)

rep_lengthout_TF(lttrs, lengthout=15 , each = 2,index=[True])

###################################################



#Example 3
#> rep(letters[1:3],each=3,times=2)
# [1] "a" "a" "a" "b" "b" "b" "c" "c" "c" "a" "a" "a" "b" "b" "b" "c" "c" "c"
#repeat a:c each element 3  and repeat this 2 times

result_numpy=numpy.repeat(lttrs,3)
result_itertools=list(itertools.repeat(result_numpy,2))
rd= list(itertools.chain(*list(result_itertools)))
print(rd)

rep_times_TF(lttrs, times = 2, each = 3,index=[True])


######################################################


#Example 4
#> rep(letters[c(TRUE,FALSE)],each=2)
# [1] "a" "a" "c" "c" "e" "e" "g" "g" "i" "i" "k" "k" "m" "m" "o" "o" "q" "q" "s" "s" "u" "u"
#[23] "w" "w" "y" "y"

lttrs_TF=index_TF(letters,[True,False])
input=numpy.repeat(lttrs_TF, 2)
rd=list(input)
print(rd)

rep_times_TF(letters, times = 1, each = 2,index=[True,False])

#####################################
#Example 5
#> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2)
# [1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
lttrs_TF=index_TF(letters,[True,False,True,False,False])
input=numpy.repeat(lttrs_TF, 2)
rd=list(input)
print(rd)

rep_times_TF(letters, times = 1, each = 2,index=[True,False,True,False,False])

#Example 6
#> rep(letters[c(TRUE,FALSE,TRUE,FALSE,FALSE)],each=2,len=25)
#[1] "a" "a" "c" "c" "f" "f" "h" "h" "k" "k" "m" "m" "p" "p" "r" "r" "u" "u" "w" "w" "z" "z"
#[23] "a" "a" "c"
lttrs_TF=index_TF(letters,[True,False,True,False,False])
input=itertools.cycle(numpy.repeat(lttrs_TF, 2))
output=list(itertools.islice(itertools.cycle(input), 25))
print(output)



rep_lengthout_TF(letters, lengthout=25 , each = 2,index=[True,False,True,False,False])