逆引き辞書 Python, R, Julia （その 4）

メッシュグリッド

# Python
a, b = np.meshgrid([1,2,3], [4, 5, 6, 7])
a
# array([[1, 2, 3],
#        [1, 2, 3],
#        [1, 2, 3],
#        [1, 2, 3]])
b
# array([[4, 4, 4],
#        [5, 5, 5],
#        [6, 6, 6],
#        [7, 7, 7]])

# R
x = matrix(0, 4, 3)

col(x) # 列番号を要素とする行列
#      [,1] [,2] [,3]
# [1,]    1    2    3
# [2,]    1    2    3
# [3,]    1    2    3
# [4,]    1    2    3
#
row(x) # 行番号を要素とする行列
#  [,1] [,2] [,3]
# [1,]    1    1    1
# [2,]    2    2    2
# [3,]    3    3    3
# [4,]    4    4    4
#
row(x)+3 # 加工すればよい
#      [,1] [,2] [,3]
# [1,]    4    4    4
# [2,]    5    5    5
# [3,]    6    6    6
# [4,]    7    7    7

# Julia
function meshgrid(x, y)
    nr = length(y)
    nc = length(x)
    transpose(reshape(repeat(x, nr), nc, :)), reshape(repeat(y, nr), nr, :)
end

a, b = meshgrid([1,2,3], [4, 5, 6, 7])
# a : [1 2 3; 1 2 3; 1 2 3; 1 2 3]
# b : [4 4 4 4; 5 5 5 5; 6 6 6 6; 7 7 7 7]

配列の連結

# Python
a = np.array([1.0, 2.0, 3.0])           # [ 1.  2.  3.]
b = np.array([5.0, 6.0, 7.0])           # [ 5.  6.  7.]
np.vstack((a, b))                       # [[ 1.,  2.,  3.], # np でも同じ
                                        #  [ 5.,  6.,  7.]]
np.hstack((a, b))                       # [ 1.,  2.,  3.,  5.,  6.,  7.]
#
x = np.array([[1, 2, 3], [4, 5, 6]])
y = np.array([[10, 11, 12], [20, 21, 22]])

np.vstack((x, y))                       # [[ 1,  2,  3], # rbind
                                        #  [ 4,  5,  6],
                                        #  [10, 11, 12],
                                        #  [20, 21, 22]]

np.hstack((x, y))                       # [[ 1,  2,  3, 10, 11, 12], # cbind
                                        #  [ 4,  5,  6, 20, 21, 22]]
#
np.concatenate((a, b))                  # [ 1.,  2.,  3.,  5.,  6.,  7.]

np.concatenate(([a], [b]))              # [[ 1.,  2.,  3.],
                                        #  [ 5.,  6.,  7.]]
#
np.concatenate((x, y), axis=0)  # [[ 1,  2,  3],
                                        #  [ 4,  5,  6],
                                        #  [10, 11, 12],
                                        #  [20, 21, 22]]

np.concatenate((x, y), axis=1)  # [[ 1,  2,  3, 10, 11, 12],
                                        #  [ 4,  5,  6, 20, 21, 22]]
#
np.c_[a, b]                             # [[ 1.,  5.],              R: cbind()
                                        #  [ 2.,  6.],
                                        #  [ 3.,  7.]]

np.r_[a, b]                             # [ 1.,  2.,  3.,  5.,  6.,  7.]     R: rbind()
#
np.c_[x, y]                             # [[ 1,  2,  3, 10, 11, 12],
                                        #  [ 4,  5,  6, 20, 21, 22]]

np.r_[x, y]                             # [[ 1,  2,  3],
                                        #  [ 4,  5,  6],
                                        #  [10, 11, 12],
                                        #  [20, 21, 22]]

# R
a = c(1, 2, 3)
b = c(5, 6, 7)
x = matrix(1:6, ncol=3, byrow=TRUE)
y = matrix(c(10, 11, 12, 20, 21, 22), ncol=3, byrow=TRUE)

rbind(a, b)
cbind(a, b) # np.c_ に相当
c(a, b)
append(a, b)

rbind(x, y)
cbind(x, y)

# Julia
a = [1, 2, 3]
b = [5, 6, 7]
x = [1 2 3; 4 5 6]
y = [10 11 12; 20 21 22]

vcat(a, b) # [1, 2, 3, 4, 5, 6]
hcat(a, b) # [1 5; 2 6; 3 7]

vcat(x, y)
# 1   2   3
# 4   5   6
# 10  11  12
# 20  21  22

hcat(x, y)
# 1  2  3  10  11  12
# 4  5  6  20  21  22

逆引き辞書 Python, R, Julia （その 3）

次元数の変更

# Python
a = np.reshape(np.arange(9), (3, 3)) # array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
b = np.reshape(np.arange(9), (3, -1))
c = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])
d = np.reshape(c, (9,))              # array([0, 1, 2, 3, 4, 5, 6, 7, 8])

# Julia
vec1 = collect(1:6);   # [1, 2, 3, 4, 5, 6]
reshape(vec1, 2, 3);   # [1 3 5; 2 4 6]　# 2x3 行列
reshape(vec1, (2, 3)); # [1 3 5; 2 4 6]　# 2x3 行列
reshape(vec1, 2, :);   # [1 3 5; 2 4 6]  # 2x3 行列
reshape(vec1, 6, :);   # 6x1 行列

リサイズ（インプレースで変更）

# Python
d = np.arange(4); d.resize((6,)); d # [0, 1, 2, 3, 0, 0]
a = np.array([[1, 2, 3], [4, 5, 6]])
a.resize((6,))                      # [1, 2, 3, 4, 5, 6]; 行列からベクトル
#
e = np.arange(4)
e.resize((4, 2)) # [[0, 1], [2, 3], [0, 0], [0, 0]] # ベクトルから行列

行列をベクトルに変更，スカラーさえも

# Python
x = np.array([[1,2,3,4],[5,6,7,8]]); np.ravel(x)
np.ravel(1) # [1]

# R
x = matrix(1:8, byrow=TRUE, ncol=4)
c(t(x)) # 列優先
c(x)    # 行優先なら c(x)

# Julia
x = [1 2 3 4; 5 6 7 8]
vec(x') # [1, 2, 3, 4, 5, 6, 7, 8]
vec(x)  # [1, 5, 2, 6, 3, 7, 4, 8]

a = 1
[a]

単位行列

# Python
np.identity(3)
np.eye(3)
np.eye(3, 5) # 3x5 行列

# R
diag(3)

# Julia
using LinearAlgebra
Array{Int}(I, 3, 3)　   # 3x3 行列
Array{Float64}(I, 3, 3)
Array{Float64}(I, 2, 3) # 2x3 行列

対角行列

# Python
np.diag([1, 3, 9])

# R
diag(c(1, 3, 9)) # 対角要素が c(1, 3, 9)
diag(3, 5)       # 対角要素が 3 の 5x5 行列

# Julia
diagm(0 => 1:3)
diagm(0 => [1, 3, 9])
diagm(1 => [1, 3, 9])                   # 対角要素の 1 つ上。従って 4x4 行列
diagm(-2 => [1, 3, 9])                  # 対角要素の 2 つ下。従って 5x5 行列
diagm(1 => [1, 3, 9], -2 => [2, 6, 13]) # 複数指定も可
Diagonal([1, 2, 3])
Diagonal(ones(3))
Diagonal(ones(Int, 3))

対角成分へ代入

# Python
r = np.reshape(np.arange(1, 10), (3, 3))
diag2 = np.eye(3) == 1
r[diag2] = 999 # [[999, 2, 3], [4, 999, 6], [7, 8, 999]]

# R
r = matrix(1:9, byrow=TRUE, 3)
diag(r) = 999

Julia には用意されていないようなので，独自関数を定義する。

function diag!(a, b)
    [a[i, i] = b[i] for i=1:length(b)]
end

a = [1 2 3; 4 5 6; 7 8 9]
b = [10 20 30]

diag!(a, b)
a

対角成分の取り出し

# Python
r = np.reshape(np.arange(1, 10), (3, 3))
np.diag(r)      # [1, 5, 9]
np.diag(r, 1)   # [2, 6] 対角線の 1 つ上
np.diag(r, -2)  # [7] 対角線の 2 つ下

# R
r = matrix(1:9, byrow=TRUE, 3)
diag(r)         # c(1, 5, 9)

# Julia
r = [1 2 3; 4 5 6; 7 8 9]
diag(r)         # [1, 5, 9]
diag(r, 1)      # [2, 6]
diag(r, -2)     # [7]

三角行列

要素が 1 の下三角行列の作成

# Python
np.tri(3)
np.tri(2, 5, 2)
np.tri(3, 5, -1)

# R
a = matrix(0, 3, 3)
a[lower.tri(a, diag=TRUE)] = 1 # np.tri(n) に相応

下三角行列（上三角行列）の抽出

# Python
a = np.reshape(np.arange(1, 10), (3,3))
# array([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])
np.tril(a)
# array([[1, 0, 0],
#        [4, 5, 0],
#        [7, 8, 9]])
np.tril(a, -1)         # 対角成分より一つ下（対角を含まない）
# array([[0, 0, 0],
#        [4, 0, 0],
#        [7, 8, 0]])
np.triu(a)
# array([[1, 2, 3],
#        [0, 5, 6],
#        [0, 0, 9]])
np.triu(a, -1)         # 対角成分より一つ下（対角を含まない）
# array([[1, 2, 3],
#        [4, 5, 6],
#        [0, 8, 9]])

# R
ifelse(lower.tri(a, diag=TRUE), a, 0)
ifelse(lower.tri(a), a, 0)            # 対角成分より一つ下
ifelse(upper.tri(a, diag=TRUE), a, 0)
ifelse(upper.tri(a), a, 0)            # 対角成分より一つ上

# Julia
a = [1 2 3; 4 5 6; 7 8 9]
[i <= j ? a[j, i] : 0 for j = 1:n, i = 1:n] # 不等式部分でどこから取り出すかを指定
[i < j ? a[j, i] : 0 for j = 1:n, i = 1:n]
[i >= j ? a[j, i] : 0 for j = 1:n, i = 1:n]
[i >= j-1 ? a[j, i] : 0 for j = 1:n, i = 1:n]

下三角行列の要素をベクトルとして抽出

# Python
a = np.reshape(np.arange(1, 10), (3,3))
# array([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])
#
b = np.tril(np.ones_like(a)) > 0
# array([[ True, False, False],
#        [ True,  True, False],
#        [ True,  True,  True]])
a[b]    # [1, 4, 5, 7, 8, 9]
#
b2 = np.triu(np.ones_like(a)) > 0
# array([[ True,  True,  True],
#        [False,  True,  True],
#        [False, False,  True]])
a[b2]    # [1, 2, 3, 5, 6, 9]
#
c = np.tril(np.ones_like(a), -1) > 0
# array([[False, False, False],
#        [ True, False, False],
#        [ True,  True, False]])
a[c]    # [4, 7, 8]
#
c2 = np.triu(np.ones_like(a), -1) > 0
# array([[ True,  True,  True],
#        [ True,  True,  True],
#        [False,  True,  True]])
a[c2]    # array([1, 2, 3, 4, 5, 6, 8, 9])

# R
a = matrix(1:9, 3, byrow=TRUE)
#
a[lower.tri(a, diag=TRUE)] # c(1, 4, 7, 5, 8, 9); 列優先になる
a[upper.tri(a, diag=TRUE)] # c(1, 2, 5, 3, 6, 9)
#
a[lower.tri(a)] # c(4, 7, 8)
a[upper.tri(a)] # c(2, 3, 6)

# Julia
a = [1 2 3; 4 5 6; 7 8 9]
using LinearAlgebra
a[tril(trues(size(a)))] # [1, 4, 7, 5, 8, 9]; 列優先になる
a[triu(trues(size(a)))] # [1, 2, 5, 3, 6, 9]

下三角行列（上三角行列）への代入

# Python
r = np.reshape(np.arange(1, 10), (3, 3))
# array([[1, 2, 3],
#        [4, 5, 6],
#        [7, 8, 9]])
p = 100 * r
# array([[100, 200, 300],
#        [400, 500, 600],
#        [700, 800, 900]])
lower = np.tri(3) == 1
r[lower] = p[lower]
print(r)
# array([[100,   2,   3],
#        [400, 500,   6],
#        [700, 800, 900]])

# R
r = matrix(1:9, 3, byrow=TRUE)
#      [,1] [,2] [,3]
# [1,]    1    2    3
# [2,]    4    5    6
# [3,]    7    8    9
p = 100 * r
#      [,1] [,2] [,3]
# [1,]  100  200  300
# [2,]  400  500  600
# [3,]  700  800  900
ifelse(lower.tri(p, diag=TRUE), p, r)
#      [,1] [,2] [,3]
# [1,]  100    2    3
# [2,]  400  500    6
# [3,]  700  800  900
ifelse(upper.tri(p, diag=TRUE), p, r)
#      [,1] [,2] [,3]
# [1,]  100  200  300
# [2,]    4  500  600
# [3,]    7    8  900

# Julia
r = [1 2 3; 4 5 6; 7 8 9]
# 1  2  3
# 4  5  6
# 7  8  9
p = 100 * r
# 100  200  300
# 400  500  600
# 700  800  900
n = size(p, 1)
[i > j ? r[i, j] : p[i, j] for j = 1:n, i = 1:n]
# 100    4    7
# 200  500    8
# 300  600  900
[i < j ? r[i, j] : p[i, j] for j = 1:n, i = 1:n]
# 100  400  700
#   2  500  800
#   3    6  900

 

逆引き辞書 Python, R, Julia （その 2）

初期化した配列（ベクトル，行列）

ゼロベクトル

# Python
np.zeros(3)

# R
integer(3)
numeric(3)
logical(3)

# Julia
zeros(3)       # [0.0, 0.0, 0.0]
zeros(Int, 3)  # [0, 0, 0]
zeros(Bool, 3) # [0 0 0]
falses(3)      # [0 0 0]

ゼロマトリックス

# Python
np.zeros((3, 4))

# R
matrix(0, 3, 4)

# Julia
zeros(3, 4)         # [0.0 0.0 0.0; 0.0 0.0 0.0; 0.0 0.0 0.0]
zeros(Int, 3, 4)    # [0 0 0; 0 0 0; 0 0 0]
zeros(Bool, 3, 4)   # [0 0 0; 0 0 0; 0 0 0]

1 ベクトル

# Python
np.ones(3)

# R
rep(1, 3)

# Julia
ones(3)         # [1.0, 1.0, 1.0]
ones(Int, 3)    # [1, 1, 1]
ones(Bool, 3)   # [1, 1, 1]
trues(3)        # [1, 1, 1]

1 マトリックス

# Python
np.ones((3, 4))

# R
matrix(1, 3, 4)

# Julia
ones(3, 4)      # [1.0 1.0 1.0; 1.0 1.0 1.0; 1.0 1.0 1.0]
ones(Int, 3, 4) # [1 1 1; 1 1 1; 1 1 1]

一定値で初期化するベクトル

# Python
np.repeat(123, 3)
np.full(3, 123)

# R
rep(123, 3)

# Julia
fill(123, 3) # [123, 123, 123]

一定値で初期化するマトリックス

# Python
np.array([[123]*4 for i in range(3)])
np.full((3, 4), 123)

# R
matrix(123, 3, 4)

# Julia
fill(123, 3, 4) # [123 123 123 123; 123 123 123 123; 123 123 123 123]

初期化しないベクトル，行列

# Python
np.empty(5)
np.empty(5, 7)

# Julia
V = Array{Float64, 1}(undef, 5)     # 型の指定は Int64, Int, Bool など
A = Array{Float64, 2}(undef, 5, 7)

既存のベクトル，行列と同じサイズのベクトル，行列

# Python
a = np.ones(5)
np.ones_like(a)
np.zeros_like(a)
np.empty_like(a)
#
b = np.ones((2, 3))
np.ones_like(b)
np.zeros_like(b)
np.empty_like(b)

# Julia
a = ones(5)
a2 = similar(a) # サイズだけが同じで初期化されていないベクトル
b = zeros(2, 3)
b2 = similar(b) # サイズだけが同じで初期化されていない行列

ソート

# Python
a = [4, 1, 3, 5, 2]
sorted(a)
sorted(a, reverse=True)
#
a.sort()
a.sort(reverse=True)   # インプレースでソート
#
b = np.array([[4, 3, 5], [3, 2, 1]])
b.sort(axis=1)         # インプレース・次元指定でソート
#
c = np.sort(b, axis=1) # np.sort はインプレースではない

# R
a = c(4, 1, 3, 5, 2)
sort(a)
sort(a, decreasing=TRUE)
#
x = matrix(c(4, 3, 5, 3, 2, 1), byrow=TRUE, ncol=3)
t(apply(x, 1, sort))  # 次元指定でソート

# Julia
a = [4, 1, 3, 5, 2];
sort(a)
sort(a, rev=true)
#
sort!(a) # インプレースでソート
sort!(a, rev=true) # インプレースで逆順ソート

逆転

# Python
a = [4, 1, 3, 2, 5]
a.reverse()
a[::-1]
#
reversed(a) # 逆順のイテレータ

# R
a = c(4, 1, 3, 2, 5)
rev(a)
a[seq(length(a), 1, by=-1)]

# Julia
a = [4, 1, 3, 2, 5]
reverse(a)      # [5, 2, 3, 1, 4]
a[end:-1:begin] # [5, 2, 3, 1, 4]

小さい順の要素のインデックス

x[o] とすると x がソートされるような o

# Python
x = np.array([2, 1, 2, 3, 4, 5, 4, 3, 4, 6])
o = x.argsort() # array([1, 0, 2, 3, 7, 4, 6, 8, 5, 9]) # 0 から始まる
x[o]            # array([1, 2, 2, 3, 3, 4, 4, 4, 5, 6])
(-x).argsort()  # array([9, 5, 4, 6, 8, 3, 7, 0, 2, 1])

# R
x = c(2, 1, 2, 3, 4, 5, 4, 3, 4, 6)
o = order(x)                           # c(2, 1, 3, 4, 8, 5, 7, 9, 6, 10) # 1 から始まる
x[o] = c(1, 2, 2, 3, 3, 4, 4, 4, 5, 6)
order(x, decreasing=TRUE)              # c(10, 6, 5, 7, 9, 4, 8, 1, 3, 2)

# Julia
x = [2, 1, 2, 3, 4, 5, 4, 3, 4, 6]
o = sortperm(x) # [2, 1, 3, 4, 8, 5, 7, 9, 6, 10]
x[o]            # [1, 2, 2, 3, 3, 4, 4, 4, 5, 6]

逆順ソートに対応するベクトル ro を返す。
ro = sortperm(x, rev=true) # [10, 6, 5, 7, 9, 4, 8, 1, 3, 2]
x[ro] # [6, 5, 4, 4, 4, 3, 3, 2, 2, 1]

等差数列

公差=1

# Python
list(range(5))
np.array(range(5))
np.arange(5)

# R
0:4
seq(0, 4)

# Julia
Vector(0:4)                     # [0, 1, 2, 3, 4]
collect(0:4)                    # [0, 1, 2, 3, 4]
range(0, 4, step=1)             # 0:1:4 # イテレータ
collect(range(0, 4, step=1))    # [0, 1, 2, 3, 4]

公差≠1

# Python
np.arange(10, 13, 0.5) # array([10., 10.5, 11., 11.5, 12., 12.5])

# R
seq(10, 12.5, 0.5)     # c(10, 10.5, 11, 11.5, 12, 12.5)

# Julia
Vector(10:0.5:12.5)                 # [10.0, 10.5, 11.0, 11.5, 12.0, 12.5]
collect(10:0.5:12.5)                # [10.0, 10.5, 11.0, 11.5, 12.0, 12.5]
range(10, 12.5, step=0.5)           # 10.0:0.5:12.5 # イテレータ
collect(range(10, 12.5, step=0.5))  # [10.0, 10.5, 11.0, 11.5, 12.0, 12.5]

長さ指定

# Python
np.linspace(1, 6, 5) # [1., 2.25, 3.5, 4.75, 6.]

# R
seq(1, 6, length=5)  # c(1, 2.25, 3.5, 4.75, 6)

# Julia
collect(1:(6-1)/4:6)            # [1.0, 2.25, 3.5, 4.75, 6.0]
range(1, 6, length=5)           # 1.0:1.25:6.0 # イテレータ
collect(range(1, 6, length=5))  # [1.0, 2.25, 3.5, 4.75, 6.0]

等比数列

# Python
np.logspace(0, 2, num = 3, dtype=int) # array([1, 10, 100]) i.e. 10^0, 10^1, 10^2
np.logspace(0, 5, num = 6, base=3)    # array([1., 3., 9., 27., 81., 243.])

# R
10^(0:2) # c(1, 10, 100)
3^(0:5)  # c(1, 3, 9, 27, 81, 243)

10 .^ (0:2) # [1, 10, 100]
3 .^ (0:5)  # [1, 3, 9, 27, 81, 243]

乱数

乱数の種

# Python
import random
random.seed(123)
#
np.random.seed(123)

# R
set.seed(123)

# Julia
using Random
Random.seed!(123)

一様乱数

# Python
random.random()                  # [0, 1) の一様乱数を 1 個
random.uniform(min, max)         # [min, max) の一様乱数
random.randint(min, max)         # [min, max] の整数一様乱数
np.random.rand(n)                # [0, 1) の一様乱数を n 個
np.random.randint(min, max, n)   # [min, max) の整数一様乱数を n 個

# R
runif(n, min, max)               # [min, max) の一様乱数を n 個
sample(min:max, n, replace=TRUE) # [min, max] の整数一様乱数 を n 個
sample(max, n, replace=TRUE)     # [1, max] の整数一様乱数 を n 個

# Julia
rand(n)         # Float64 の [0, 1) の一様乱数
rand(Int8, n)   # Int8 の一様乱数を n 個
rand(Int32, n)  # Int32 の一様乱数を n 個

無作為抽出

# Python
random.randint(min, max)            # [min, max] の整数一様乱数 1 個
np.random.randint(min, max, n)      # [min, max) の整数一様乱数 n 個
np.random.sample(["A", "B", "C"], n, replace=True)

# R
sample(min:max, n, replace=TRUE)    # [min, max] の整数一様乱数 n 個
sample(c("A", "B", "C"), n, replace=TRUE)

# Julia
n = 3; min0=1; max0=6
rand(min0:max0, n)                  # min0:max0 から n 個を無作為抽出
rand(["A", "B", "C"], n)            # ベクトル要素を無作為抽出
rand(('x', 'y', :z), n)             # ベクトル要素を無作為抽出
rand(2, 3)                          # 2x3 の一様乱数行列

ベクトルをシャッフル（重複なしの無作為抽出）

# Python
np.shuffle(x)

# R
sample(x)

# Julia
x = collect(1:10)
shuffle(x)

正規乱数

# Python
random.normalvariate(mean, std)     # 平均値 = mean, 標準偏差 = std の正規乱数 1 個
random.gauss(mean, std)             # 平均値 = mean, 標準偏差 = std の正規乱数 1 個
np.random.normal(mean, std, n)      # 平均値 = mean, 標準偏差 = std の正規乱数 n 個
np.random.normal(mean, std, (n, m)) # nxm の正規乱数行列

# R
rnorm(n, mean, sd)                  # 平均値 = mean, 標準偏差 = sd の正規乱数 n 個
matrix(rnorm(n*m, mean, sd), n, m)  # nxm の正規乱数行列

# Julia
Random.seed!(123)
randn(3)                            # 長さ 3 の正規乱数ベクトル（平均値 = 0，標準偏差 = 1 に固定）
randn(3, 4)                         # 3x4 の正規乱数行列

逆引き辞書 Python, R, Julia （その 1）

in 演算子

# Python
a = range(1, 11)
3 in range(1, 11) # True
3 in a            # True
not(3 in a)       # False
20 not in a       # True

# R
a = 1:10
3 %in% a        # TRUE
!(3 %in% a)     # FALSE
20 %in% a       # FALSE

# Julia
a = 1:10        # 1:10
b = collect(a)  # [1, 2, ..., 9, 10]
typeof(a)       # UnitRange{Int64}
typeof(b)       # Array{Int64,1}
3 in a          # true
3 in b          # true
!(3 in a)       # false
20 in a         # false

どこにあるか

# Python
a = [3, 1, 0, 2, 4, 0, 3, 5, 4, 2]
a.index(4)                 # 4
#
b = np.array([3, 2, 1, 2, 3, 4, 1])
c = np.where(b == 1)       # (array([2, 6]),)
c[0]                       # array([2, 6])
c[0][0]                    # 2
c[0][1]                    # 6

# R
a = c(3, 1, 0, 2, 4, 0, 3, 5, 4, 2)
which(a == 4)               # 5, 9

# Julia
a = [3, 1, 0, 2, 4, 0, 3, 5, 4, 2]
findfirst(==(4), a)         # 5
findfirst(isequal(4), a)    # 5
#
findfirst(>(3), a)          # 5
findall(iseven, a)          # [3, 4, 5, 6, 9, 10]
findall(isodd, a)           # [1, 2, 7, 8]
#
findfirst(==(3), a)         # 1
findlast(==(3), a)          # 7
findall(==(3), a)           # [1, 7]

いくつあるか

# Python
a = [3, 1, 0, 2, 4, 0, 3, 5, 4, 2]
a.count(3)                  # 2

# R
a = c(3, 1, 0, 2, 4, 0, 3, 5, 4, 2)
length(which(a == 3))       # 2

# Julia
a = [3, 1, 0, 2, 4, 0, 3, 5, 4, 2]
count(==(3), a)             # 2
count(isequal(3), a)        # 2

三項演算子

# Python
i = 6
a = "even" if i % 2 == 0 else "odd"     # 'even'

# R
i = 6
a = if (i %% 2 == 0) "even" else "odd"  # "even"

# Julia
i = 6
a = i % 2 == 0 ? "even" : "odd"         # "even"

条件により実行される演算を選択する

# Python
import numpy as np
a = np.array([2, 3, 5, 6, 8])
b = np.where(a % 2 == 0, a*10, 0)     # array([20,  0,  0, 60, 80])

# R
a = c(2, 3, 5, 6, 8)
b = ifelse(a %% 2 == 0, a*10, 0)      # c(20, 0, 0, 60, 80)

# Julia
a = [2, 3, 5, 6, 8];
b = map(x -> x % 2 == 0 ? 10x : 0, a) # [20, 0, 0, 60, 80]

リスト（配列）同士の連結

# Python
a = [1, 2, 3]
b = [11, 12]
x = a + b           # [1, 2, 3, 11, 12]; インプレースではない
#
import operator as op
y = op.concat(a, b) # [1, 2, 3, 11, 12]
#
a.extend(b)         # [1, 2, 3, 11, 12]; a にインプレースで連結
#
a2 = np.array([1, 2, 3])
b2 = np.array([11, 12])
x = np.hstack((a2, b2)) # array([1, 2, 3, 11, 12]); インプレースではない

# R
a = c(1, 2, 3)
b = c(11, 12)
x = c(a, b)         # c(1, 2, 3, 11, 12); インプレースではない
y = append(a, b)    # c(1, 2, 3, 11, 12); インプレースではない

# Julia
a = [1, 2, 3];
b = [11, 12];
x = vcat(a, b)      # [1, 2, 3, 11, 12]; インプレースではない
append!(a, b)       # [1, 2, 3, 11, 12]; a にインプレースで連結

リストに変数を連結

# Python
a = [1, 2, 3]
b = 5
x = a + [b]         # [1, 2, 3, 5]; インプレースではない
a.append(b)         # [1, 2, 3, 5]; a にインプレースで連結
#
a2 = np.array([1, 2, 3])
b = 5
x = np.hstack((a2, b)) # [1, 2, 3, 5]; インプレースではない

# R
a = c(1, 2, 3)
b = 5
x = c(a, b)         # c(1, 2, 3, 5); インプレースではない
y = append(a, b)    # c(1, 2, 3, 5); インプレースではない

# Julia
a = [1, 2, 3]
b = 5
x = vcat(a, b)      # [1, 2, 3, 5]; インプレースではない
append!(a, b)       # [1, 2, 3, 5]; a にインプレースで追加

リストに変数を挿入

# Python
a = [1, 2, 3]
b = 5
a.insert(0, b)      # [5, 1, 2, 3]; a にインプレースで挿入

# R
a = c(1, 2, 3)
b = 5
x = append(a, b, 0) # c(5, 1, 2, 3); インプレースではない

# Julia
a = [1, 2, 3]
b = 5
insert!(a, 1, b)    # [5, 1, 2, 3]; a にインプレースで挿入

要素の全削除

# Python
a = [1, 2, 3]
a.clear()
a                 # []; 要素がなくなるのであって，a 自体がなくなるわけではない

# R
a = c(1, 2, 3)
a = NULL
a                 # NULL; 要素がなくなるのであって，a 自体がなくなるわけではない

# Julia
a = [1, 2, 3]
empty!(a)
a                 # Int64[]; 要素がなくなるのであって，a 自体がなくなるわけではない

要素の削除

# Python
a = [1, 2, 3]
del a[1]          # インデックスを指定して要素を削除
a                 # [1, 3]
#
a = [1, 2, 3]
a.remove(3)       # 指定する値を持つ要素をインプレースで削除
a                 # [1, 2]

# R
a = c(1, 2, 3)
a = a[-2]         # インプレースではないため，結果を反映させるためには代入が必要

# Julia
a = [1, 2, 3];
deleteat!(a, 2)   # a からインプレースで削除
a # [1, 3]

要素のポップ

# Python
a = [3, 2, 1, 4, 3]
a.pop()             # 3; 取り出された要素
a                   # [3, 2, 1, 4]
#
a = [3, 2, 1, 4, 3 ]
a.pop(1)            # 2; 取り出された要素
a                   # [3, 1, 4, 3]

# R 以下の関数では，取り出した要素は把握できない
pop = function(a, i=length(a)) a[-i]
#
a = c(3, 2, 1, 4, 3)
a = pop(a)
a                   # c(3, 2, 1, 4)
#
a = c(3, 2, 1, 4, 3)
a = pop(a, 3)
a                   # c(3, 2, 4, 3)

# Julia
a = [3, 2, 1, 4, 3];
pop!(a)             # 3; 取り出された要素
a                   # [3, 2, 1, 4] # a からインプレースで最後の要素を取り出す
#
a = [3, 2, 1, 4, 3];
popfirst!(a)        # 3; 取り出された要素
a                   # [2, 1, 4, 3] # a からインプレースで最初の要素を取り出す

要素のプッシュ

# Python
a = [3, 2, 1, 4, 3]
a.append(88)        # 最後の要素としてインプレースで付け加える（insert を使ってもよい）
a.insert(3, 99)     # [3, 2, 1, 99, 4, 3, 88]; 3 番目の要素としてインプレースで挿入

# R
a = c(3, 2, 1, 4, 3)
a = append(a, 88)        # インプレースではないので，代入しないと変化なし
a = append(a, 99, 3)     # インプレースではないので，代入しないと変化なし
a                        # c(3, 2, 1, 99, 4, 3, 88)

# Julia
a = [3, 2, 1, 4, 3];
pushfirst!(a, 10)        # a にインプレースで先頭に要素を押し込む
push!(a, 20)             # a にインプレースで最後尾に要素を押し込む
a                        # [10, 3, 2, 1, 4, 3, 20]

リストの繰り返し

# Python
a = [1, 2, 3]
b = a*3                  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
#
np.tile(a, 3)            # array([1, 2, 3, 1, 2, 3, 1, 2, 3])
#
np.repeat(a, 3)          # array([1, 1, 1, 2, 2, 2, 3, 3, 3])
#
np.repeat(np.array([1,2]), [2,3])    # array([1, 1, 2, 2, 2])

# R
rep(c(1, 2, 3), 3)       # c(1, 2, 3, 1, 2, 3, 1, 2, 3)
#
rep(c(1, 2, 3), each=3)  # c(1, 1, 1, 2, 2, 2, 3, 3, 3)
#
rep(c(1, 2), c(2, 3))    # c(1, 1, 2, 2, 2)

# Julia
repeat([1, 2, 3], 3)     # [1, 2, 3, 1, 2, 3, 1, 2, 3]
#
repeat([1 2 3], inner=(1, 2))               # [1 1 2 2 3 3]; 1x6 行列
reshape(repeat([1 2 3], inner=(1,2)), 6, :) # [1, 1, 2, 2, 3, 3]; 6x1 行列
#
# 関数定義
repeateach(x, n) = vec([j for i = 1:n, j in x])
a = repeateach([1, 2, 3], 3)        # [1, 1, 1, 2, 2, 2, 3, 3, 3]
a = repeateach(["a", "b", "c"], 2)　# ["a", "a", "b", "b", "c", "c"]