［Python］文字列を連結する

+演算子を使う。

>>> s = 'a' + 'bc' + 'def'
>>> print(s)
abcdef

［Python］raw文字列を使う

raw文字列とは、エスケープシーケンスを無効にして、表記のままに文字列を解釈する文字列リテラルのこと。文字列リテラルの先頭にrをつけて表記する。

>>> s = "a\nbc\ndef"
>>> print(s)
a
bc
def
>>> s = r"a\nbc\ndef"
>>> print(s)
a\nbc\ndef

Windowsのパス区切り記号￥（円記号）は、普通の文字列リテラルでは「\\」（\を2つ）と表記する必要があるが、raw文字列を使うとそのまま書くことができる。

>>> s = "C:\\Windows\\System"
>>> print(s)
C:\Windows\System
>>> s = r"C:\Windows\System"
>>> print(s)
C:\Windows\System

［Python］アンパックを使う

シーケンスはアンパックを使用して、まとめて代入することができる。

>>> n = [1, 4, 9, 16]
>>> a, b, c, d = n
>>> print(a, b, c, d)
1 4 9 16
>>> s = ['A', 'BC', 'DEF']
>>> a, b, c = s
>>> print(a, b, c)
A BC DEF

シーケンスの要素数と代入先の変数の数が異なる場合はエラーが発生する。

>>> n = [1, 4, 9, 16]
>>> a, b = n
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

［Python］変数の値を入れ替える

コンマを使用して代入演算子で代入する。

>>> x = 2
>>> y = 4
>>> print(x, y)
2 4
>>> x, y = y, x
>>> print(x, y)
4 2

［Python］リストから指定の要素の値を得る

[ ]演算子を使ってインデックスを指定する。取得したい要素の番号を与える。ベクトルのインデックスは0および正数の整数であることに注意。

>>> s = ['abc', 'de', 'f']
>>> print(s[0])
abc
>>> print(s[1])
de
>>> print(s[2])
f

［Python］リストの要素数を得る

len関数を使う。

>>> s = ['abc', 'de', 'f']
>>> print(len(s))
3
>>> s = []
>>> print(len(s))
0

［Python］日時を文字列に変換する

strftimeメソッドを使う。

>>> import datetime
>>> dt = datetime.datetime.now()
>>> print(dt)
2022-09-23 12:36:14.938030
>>> print(dt.strftime("%Y年%m月%d日%H時%M分%S秒"))
2022年09月23日12時36分14秒
>>> len(dt.strftime("%Y年%m月%d日%H時%M分%S秒"))
20

［Python］リストの要素を逆順に並び替える

reverseメソッドを使う。

>>> n1 = [1, 2, 3, 5, 4]
>>> s1 = ['A', 'B', 'D', 'C']
>>> print(n1)
[1, 2, 3, 5, 4]
>>> print(s1)
['A', 'B', 'D', 'C']
>>> n1.reverse()
>>> print(n1)
[4, 5, 3, 2, 1]
>>> s1.reverse()
>>> print(s1)
['C', 'D', 'B', 'A']

reservseメソッドは、指定したリスト自体の要素を並び替えることに注意。並び替えた別のリストが欲しい場合は、reversed関数を使用する。reversed関数の戻り値をlist関数に渡して、新たなリストを作成する。

>>> n2 = [1, 2, 3, 5, 4]
>>> list(reversed(n2))
[4, 5, 3, 2, 1]
>>> print(n2)
[1, 2, 3, 5, 4]

［Python］現在の日時を取得する

datetimeモジュールのnow関数を使う。

>>> import datetime
>>> dt = datetime.datetime.now()
>>> print(dt)

［Python］リストを結合する

+演算子を使う

>>> n1 = [1, 2, 3]
>>> n2 = [4, 5, 6, 7]
>>> n = n1 + n2
>>> print(n)
[1, 2, 3, 4, 5, 6, 7]

［Python］文字列型リストを作成する

文字列を単一引用符で囲んで文字列リテラルを作り、[ ]演算子でまとめる。

>>> s1 = ['A', 'B', 'C']
>>> s2 = ['a', 'bc', 'def']
>>> print(s1)
['A', 'B', 'C']
>>> print(s2)
['a', 'bc', 'def']
>>> print(s1 + s2)
['A', 'B', 'C', 'a', 'bc', 'def']

［Python］コマンドライン引数

sysモジュールのargvを使う。以下のようなスクリプトファイルを作成してargv.pyと保存する。

import sys
for i in range(0, len(sys.argv)):
    print(sys.argv[i])

以下、実行例。最初の要素（インデックスは0）にはそのスクリプトファイル名が含まれており、スクリプトファイルに引数を与えた場合は、1以降にその引数が文字列で含まれる。

>python argv.py
argv.py
>python argv.py "ABC d" 123 e f
argv.py
ABC d
123
e
f

［Python］条件演算子（三項演算子）

条件演算子（三項演算子）の使い方は以下のとおり。

値1 if 式 else 値2

式が真の場合は値1が、偽の場合は値2になる。

>>> n = 3
>>> 'A' if n > 2 else 'a'
'A'
>>> n = 1
>>> 'A' if n > 2 else 'a'
'a'

［R］丸め誤差を考慮して数値の比較を行う

コンピューターは内部では浮動小数点演算を行っている都合上、丸め誤差は避けられない。それは実数同士の演算でよく見られる。

> (1 + 2) == 3
[1] TRUE
> (0.1 + 0.2) == 0.3
[1] FALSE
> print(sprintf("%.20f", 0.1 + 0.2))
[1] "0.30000000000000004441"
> print(sprintf("%.20f", 0.3))
[1] "0.29999999999999998890"

Rには標準でVisual BasicのDecimal型に相当するベクトルの型は存在せず、計算時に工夫する方法がある。

簡単に回避する方法としてsignif関数を使う方法がある。この関数は指定した有効数字を指定した桁まで丸めることができるため（デフォルトは6桁）、比較時にこの関数を使用すればよい。

> signif(0.1 + 0.2) == 0.3
[1] TRUE
> signif(0.1 + 0.2, digits = 16) == 0.3
[1] TRUE
> signif(0.1 + 0.2, digits = 17) == 0.3
[1] FALSE
> print(sprintf("%.20f", signif(0.1 + 0.2, digits = c(15, 16, 17, 18))))
[1] "0.29999999999999998890" "0.29999999999999998890" "0.30000000000000004441" "0.30000000000000004441"
> print(sprintf("%.20f", signif(0.3, digits = c(15, 16, 17, 18))))
[1] "0.29999999999999998890" "0.29999999999999998890" "0.29999999999999998890" "0.29999999999999998890"

ちなみに、round関数でも同様のことができるが、round関数とsignif関数ではdigitsオプションの意味が違うため注意。この手の処理でround関数を使うことは推奨しない。

> round(0.1 + 0.2, digits = 15) == 0.3
[1] TRUE
> round(0.1 + 0.2, digits = 16) == 0.3
[1] FALSE
> print(sprintf("%.20f", round(0.1 + 0.2, digits = 14:17)))
[1] "0.29999999999999998890" "0.29999999999999998890" "0.30000000000000004441" "0.30000000000000004441"
> print(sprintf("%.20f", round(0.3, digits = 14:17)))
[1] "0.29999999999999998890" "0.29999999999999998890" "0.29999999999999998890" "0.29999999999999998890"

丸め誤差を完全に自動でうまく処理できる方法はなく、その計算で求められる精度を基に、その都度工夫をする必要がある。

［Python］行列の様々な情報を得る

>>> import numpy as np
>>> mx = np.array([[1, 2], [3, 4], [5, 6], [7, 8]])
>>> print(mx)
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
>>> print('次元 {}'.format(mx.ndim))
次元 2
>>> print('全要素数 {}'.format(mx.size))
全要素数 8
>>> nrow, ncol = mx.shape
>>> print('行数 {}'.format(nrow))
行数 4
>>> print('列数 {}'.format(ncol))
列数 2
>>> print(mx[2, 1])
6
>>> print(mx[3, 1])
8

［Python］月の日数を得る

calendarモジュールのmonthrange関数を使う。例えば、2000年2月の日数（この年は閏年のため29）、2022年8月の日数（31）を求める。

>>> wday, mday = calendar.monthrange(2000, 2)
>>> print(wday, mday)
1 29
>>> wday, mday = calendar.monthrange(2022, 8)
>>> print(wday, mday)
0 31

一つ目の戻り値はその月の最初の日（1日）の曜日（0:月～6:日）。2000年2月1日は火曜日（=1）、2022年8月1日は月曜日（=0）ということ。

［R］数値型と数値リテラル

Rでよく使われる数値には2種類ある。

1. 整数型
2. 浮動小数点数型

1は整数を扱う。2はいわゆる実数を扱う。

整数型の数値ベクトルを作成するには、as.integer関数を使う。浮動小数点数型の数値ベクトルとはas.double関数を使う。

> n <- as.integer(3)
> d <- as.double(4.5)
> typeof(n)
[1] "integer"
> typeof(d)
[1] "double"

ここで、式や関数の引数で使う、3や4.5といった数値を表したものを数値リテラルという。3は整数リテラル、4.5は浮動小数点数リテラルという。だが、Rでは通常の計算は全て浮動小数点数で扱われるため、整数や浮動小数点数といったことを意識することはあまりない。

> typeof(3)
[1] "double"
> typeof(4.5)
[1] "double"

これまでベクトルのインデックスには演算子[ ]を使用して数値型ベクトルを与えて使用してきたが、与える数値は明示的に整数型にしなくてもよい。この場合は、与えた数値型ベクトルの要素は強制的に整数されてしまう（小数点以下が無視される）。

> s <- c("A", "B", "C")
> s[c(2, 3)]
[1] "B" "C"
> s[c(2.1, 3)]
[1] "B" "C"
> s[c(2.1, 3.9)]
[1] "B" "C"

これは浮動小数点数型を与えてもよいと理解せずに、ベクトルのインデックスには整数リテラルを与えるようにすること。

［Python］文字列の前後の空白を取り除く

strip関数、lstrip関数、rstrip関数を使う。それぞれ、前後、前だけ、後ろだけの空白（0x20）を削除した文字列を返す。

>>> s = ' AB C  DE  '
>>> s
' AB C  DE  '
>>> s.strip()
'AB C  DE'
>>> s.lstrip()
'AB C  DE  '
>>> s.rstrip()
' AB C  DE'

［R］ベクトルから指定の要素を取り除く

要素を取り出す場合、インデックスに正数の数値を与えればよいが、取り除く場合は、インデックスに負数の数値を与えればよい。

> s <- c("A", "B", "C", "D", "E")
> s[c(1, 2, 4)]
[1] "A" "B" "D"
> s[-c(1, 2, 4)]
[1] "C" "E"
> s[c(-1, -2, -4)]
[1] "C" "E"
> s[-c(100)]
[1] "A" "B" "C" "D" "E"

最後の例のとおり、存在しないインデックスの負数を与えると無視される。