kogi3_train.tsv

タイムスタンプデータをn週間前に戻す	aDatetime - datetime.timedelta(weeks=n)
＜オプション＞グラフの色をダークバイオレットに設定する	color = 'darkviolet'
二つの集合に共通する要素からなる集合	aSet.intersection(aSet2)
セットの濃度	len(aSet)
ファイル名がCSVファイルかどうか	filename.endswith('.csv')
双方向キューの先頭にイテラブルの各要素を付け加える	deq.extendleft(iterable)
グラフの横軸のラベルをuntitledに設定する	plt.xlabel(untitled)
折れ線グラフを描画して、色をインディアンレッドに設定する	plt.plot(データ列, データ列2, color='indianred')
ヒストグラムの色を耐火レンガに指定する	plt.hist(データ列, color='firebrick')
データフレームを表示するとき、折り返しをしないようにする	pd.set_option('expand_frame_repr', False)
カラーバーを横向きで付ける	plt.colorbar(orientation='horizontal')
散布図をカラーコードの三角マーカーで描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
グリーンイエローにヒストグラムの色を設定する	plt.hist(データ列, color='greenyellow')
＜オプション＞マゼンタ色を使用する	color = 'magenta'
＜オプション＞ホットピンク色を使う	color = 'hotpink'
線グラフを描画してその色をライトシアンに指定する	plt.plot(データ列, データ列2, color='lightcyan')
日付データからn時間分、減算する	aDate - datetime.timedelta(hours=n)
リストを太字でプリントする	print(f'\033[1m{value}\033[0m')
線グラフを描画して、色をインディゴに設定する	plt.plot(データ列, データ列2, color='indigo')
散布図に三角マーカーを使用する	plt.plot(xdata, ydata, marker='^')
本日が木曜日か調べる	datetime.datetime.today().weekday() == 3
オブジェクトが整数クラス	isinstance(obj, int)
折れ線グラフの色をブルーバイオレットに設定する	plt.plot(データ列, データ列2, color='blueviolet')
リストの合計値を求める	sum(aList)
リストとリストについて散布図を描画する	plt.scatter(xdata, ydata)
表を'A'列と'B'列によってまとめたグループ	df.groupby(['A', 'B'])
リストと数列についての散布図に赤色のバツマーカーを描画する	plt.plot(xdata, ydata, marker='x', c='r')
nがn2よりも小さい	n < n2
文字列がリストに含まれないかどうか調べる	element not in aList
ヒストグラムを描画して、その色をダークグレーに設定する	plt.hist(データ列, color='darkgrey')
線グラフの色をダーク・スラテグレーにする	plt.plot(データ列, データ列2, color='darkslategrey')
データフレームの中の列を中央値でビン分割する	pd.qcut(df[col], 2)
一方に含まれ、他方に含まれない集合	aSet.difference(aSet2)
カウンタの要素一覧	aCounter.keys()
リストとリストの黒い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
ファイルパスをオープンして]書き込みストリームを使う	open(filepath, mode='w')
カウンタのユニークな項目を列挙する	list(aCounter)
配列とリストについて淡い色の折れ線グラフを描画して、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
データフレームのリスト列のヒートマップを描画する	sns.heatmap(df[aList].corr())
ローングリーン色のヒストグラムを描画する	plt.hist(データ列, color='lawngreen')
カラムを百の位で丸めて、整数型にする	ds.round(-2).astype(int)
ファイルパスを文字コードtextで追加できるようにオープンする]	open(filepath, mode='a', encoding=text)
折れ線グラフを描画して、その色をスカイブルーに設定する	plt.plot(データ列, データ列2, color='skyblue')
折れ線グラフを描画して、その色をシエナに指定する	plt.plot(データ列, データ列2, color='sienna')
実数のサインの逆数	math.asin(x)
３二ビット整数型のゼロ埋めされた配列	np.zeros(要素数, dtype=np.int16)
グラフの用途をポスターに設定する	sns.set(context='poster')
折れ線グラフの色をインディゴに変更する	plt.plot(データ列, データ列2, color='indigo')
ファイルパスを絶対パスに変換する	os.path.abspath(filepath)
ヒストグラムの色をライムに変更する	plt.hist(データ列, color='lime')
データフレームの列をカテゴリデータに変換する	df[col].astype(object)
アルファベットの大文字列	string.ascii_uppercase
オブジェクトはリストクラスのインスタンスか調べる	isinstance(obj, list)
データフレームのそれぞれのグループごとの個数	df.groupby(column).count()
データフレームのモードを求める	df.mode()
＜オプション＞グラフの色をダークオリーブグリーンに設定する	color = 'darkolivegreen'
日付時刻データからn日を減算する	aDatetime - datetime.timedelta(days=n)
線グラフを描画して色をハニーデューに設定する	plt.plot(データ列, データ列2, color='honeydew')
色差別ない色の折れ線グラフをプロットして、その線幅をnにセットする	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データ列の各データ値の出現数	ds.value_counts()
折れ線グラフの星マーカーを黄色くする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='y')
ヒストグラムを描画して、その色を真紅に設定する	plt.hist(データ列, color='crimson')
データフレームの列の値を正規表現で一度に置き換える	df[col].replace(pattern, repl, regex=True)
折れ線グラフの色を青紫に設定する	plt.plot(データ列, データ列2, color='violet')
明るいの折れ線グラフをイテラブルと数列で描画して、その線幅をnにセットする	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
ミディアムシアグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumseagreen')
折れ線グラフに大バツマーカーを用いる	plt.plot(データ列, データ列2, marker='X')
リストをリストを境界値として分割する	pd.cut(aList, aList)
折れ線グラフの右三角マーカーを赤くする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='r')
ヒストグラムの色をオレンジに設定する	plt.hist(データ列, color='orange')
＜オプション＞グラフの色を珊瑚に設定する	color = 'coral'
データフレームの列の値がxより大きい行を抽出する	df[df[column] > x]
文字列の中で複数行対応として正規表現にマッチしたすべての文字列をリストに変換する	re.findall(pattern, s, flags=re.MULTILINE)
文字列を正規表現で分割する	re.split(pattern, s)
＜オプション＞マーカーを丸に変更する	marker = 'o'
文字列をデックにエンキューする	deq.appendleft(element)
散布図に暗い色のマーカーを使う	plt.plot(xdata, ydata, c='dark')
グラフで使うタイトルをuntitledに設定する	plt.title(untitled)
折れ線グラフのラベルをuntitledに指定する	plt.plot(xdata, ydata, label=untitled)
nがn2の倍数でない	n % n2 != 0
＜オプション＞ダークターコイズにグラフの色を設定する	color = 'darkturquoise'
＜オプション＞ミディアムアクアマリンを使用する	color = 'mediumaquamarine'
データフレームのリストカラムが正規分布からどの程度、歪んでいるか見る	df[aList].kurt()
日付データが日付データより後ろか調べる	aDate > aDate2
列毎にデータフレームをグループ化して、グループごとの個数を求める	df.groupby(column).count()
ケンドール相関係数としてデータフレームの相関行列	df.corr(method='kendall')
データフレームから最初の列を除く	df[df.columns[1:]]
現在が何秒か知る	datetime.date.today().second
全要素を1で初期化されたベクトル	np.ones(要素数, dtype=np.int)
折れ線グラフの色をフォレストグリーンに設定する	plt.plot(データ列, データ列2, color='forestgreen')
折れ線グラフの丸印の線幅をnに指定する	plt.plot(データ列, データ列2, marker='o', markeredgewidth=n)
＜オプション＞マルーンにグラフの色を設定する	color = 'maroon'
ヒストグラムの線のスタイルを点線にセットする	plt.hist(データ列, linestyle='dotted')
折れ線グラフに緑色の左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='g')
データ列の空文字をNaNに変換しドロップする	ds.replace('', np.nan).dropna()
列がどれだけ、分散しているか調べる	ds.var()
折れ線グラフを描画して、その色をライトシアンに設定する	plt.plot(データ列, データ列2, color='lightcyan')
バイトオーダを知る	sys.byteorder
カラーバーを付ける	plt.colorbar()
線グラフを描画して、その色をサドルブラウンに設定する	plt.plot(データ列, データ列2, color='saddlebrown')
カウンタのキーとカウントを列挙する	aCounter.items()
変数を入れ替える	x, y = y, x
＜オプション＞スラグレー色を用いる	color = 'slategray'
折れ線グラフを描画して、その色をフォレストグリーンに設定する	plt.plot(データ列, データ列2, color='forestgreen')
折れ線グラフに青い三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='b')
データフレームの中の列を四分位数でビンニングする	pd.qcut(df[col], 4)
折れ線グラフを描画して、その色をミスティローズに設定する	plt.plot(データ列, データ列2, color='mistyrose')
棒グラフを積み上げにする	"plt.bar(ラベル列, データ列, bottom=データ列2, color=""red"")"
実数が負の数か確認する	x < 0
折れ線グラフの色をスラグレーに設定する	plt.plot(データ列, データ列2, color='slategray')
文字列が全て数字かどうか調べる	s.isdigit()
ファイルパスを追加用にオープンする]	open(filepath, mode='a')
日付時刻データをn週間前に戻す	aDatetime - datetime.timedelta(weeks=n)
濃いグラフの色を黒色に変更する	plt.plot(xdata, ydata, linestyle='deep', color='k')
折れ線グラフの下三角印を青くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
ダークサーモン色の線グラフを描画する	plt.plot(データ列, データ列2, color='darksalmon')
リストと配列についての散布図に赤いダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c='r')
タプルの長さ	len(aTuple)
マッピングに要素を項目名として加える	aDict[key] = element
データ列を淡い色の柱状図で描く	plt.hist(xdata, color='muted')
データフレームのn行目をドロップして更新する	df.drop(n, axis=0, inplace=True)
ファイルパスの入力ストリームを見る	open(filepath)
本日の日付時刻	datetime.datetime.now()
nの二進数表記	bin(n)
データフレームの指定された列をリストに変換する	df[column].values.tolist()
n2がnより大きく、かつ、n3未満か調べる	n < n2 and n2 < n3
リストとイテラブルを使って暗いを描画して線幅をnに指定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
データ列とリストのパステル調のを描画して色を黒色に変更する	plt.plot(xdata, ydata, linestyle='pastel', color='k')
リストと配列の散布図を描画し、、マーカーの色を濃いに設定する	plt.plot(xdata, ydata, c='deep')
黒色の右三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='>', c='k')
折れ線グラフを描画して、その色をライトサーモンに設定する	plt.plot(データ列, データ列2, color='lightsalmon')
最大長nの両端キューをイテラブルから作る	collections.deque(iterable, maxlen=n)
サドルブラウンにヒストグラムの色をセットする	plt.hist(データ列, color='saddlebrown')
データフレームを複数の列の値によってグループ化し要約統計量を求める	df.groupby(columns).describe()
リストとリストについての散布図にカラーコードの下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
データフレームのリストカラムの中に文字列と文字列があるかテストする	df[aList].isin([value, value2])
＜オプション＞グラフの色をフォレストグリーンに設定する	color = 'forestgreen'
文字列リストに配列を変換して、タブで連結する	'\t'.join(map(str, iterable))
データフレームをグループ化し、それぞれの列に対し個数を求める	df.groupby(column)[column2].count()
カウンタから最頻出な値の件数を求める	aCounter.most_common()[1]
集合をリストに変換する	list(aSet)
上限制限された長さを指定して、両端キューを生成する	collections.deque(maxlen=n)
データ列を分割する	pd.cut(ds, aList)
日付時刻データにn時間分、加算する	aDatetime + datetime.timedelta(hours=n)
データフレームのリスト列の相関行列をヒートマップを用いてグラフ化する	sns.heatmap(df[aList].corr())
配列とリストについて濃い色の折れ線グラフを描いて線幅をnにセットする	plt.plot(xdata, ydata, linewidth=n, color='deep')
折れ線グラフを描画してその色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
折れ線グラフを描画して、その色をデピンクに設定する	plt.plot(データ列, データ列2, color='deeppink')
マルーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='maroon')
タプルの中の最小値	min(aTuple)
文字列がリストの要素でないか調べる	element not in aList
赤いバツマーカーを数列とイテラブルについての散布図に描く	plt.plot(xdata, ydata, marker='x', c='r')
リストとリストの散布図を描画して、マーカーを四角に変更する	plt.plot(xdata, ydata, marker='s')
日付データからn分、減算する	aDate - datetime.timedelta(minutes=n)
折れ線グラフを描画して、色を濃いシアンに指定する	plt.plot(データ列, データ列2, color='darkcyan')
折れ線グラフの色をライトグリーンに設定する	plt.plot(データ列, データ列2, color='lightseagreen')
折れ線グラフを描画して、その色をスラグレーに設定する	plt.plot(データ列, データ列2, color='slategray')
黒いポイントマーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='.', c='k')
リストを黄色で表示できる文字列に変換する	f'\033[33m{value}\033[0m'
日付時刻データが何時か知る	aDatetime.hour
符号なし８ビット整数型のゼロ埋めされた配列を作る	np.zeros(要素数, dtype=np.uint8)
データフレームのリストカラムの中に文字列と日付データが存在するか調べる	df[aList].isin([value, value2])
辞書をJSON形式のインデント幅nの文字列に変換する	json.dumps(aDict, ensure_ascii=False, indent=n)
折れ線グラフの左三角マーカーを赤くする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='r')
標準出力	sys.stdout
ヒストグラムを描画して、その色をコーラルに設定する	plt.hist(データ列, color='coral')
ファイルパスからストリームを開き]fileとする	file = open(filepath)
データフレームの列の欠損値を最小値に増やす	df[col].fillna(df[col].min())
ヒストグラムを描画して、その色を貝殻に設定する	plt.hist(データ列, color='seashell')
折れ線グラフを描画して、色をミディアムシアグリーンに設定する	plt.plot(データ列, データ列2, color='mediumseagreen')
折れ線グラフの色をシャルトリューズに設定する	plt.plot(データ列, データ列2, color='chartreuse')
グラフの色をパステル調にする	sns.set(pallete='pastel')
ヒストグラムを描画して、その色をオリベドラブに設定する	plt.hist(データ列, color='olivedrab')
実数の二進対数	math.log2(x)
リストとリストで淡いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color='r')
集合の全ての要素が別の集合に含まれるか調べる	aSet.issubset(aSet2)
ダークシアンにヒストグラムの色を設定する	plt.hist(データ列, color='darkcyan')
整数nを八進表現に変換する	oct(n)
ヒストグラムの色をシアンに設定する	plt.hist(データ列, color='cyan')
タプルをナンバリングする	enumerate(aTuple)
ヒストグラムの色をクリムゾンに設定する	plt.hist(データ列, color='crimson')
折れ線グラフを破線を用いて描画する	plt.plot(データ列, データ列2, linestyle='dashed')
データフレームから列を二つ選択する	df[[column, column2]]
データ列は正規分布からどれだけ、尖っているか調べる	ds.skew()
透明度alphaで配列とリストの折れ線グラフを描く	plt.plot(xdata, ydata, alpha=alpha)
データ列を折れ線グラフに描画して、マーカーをダイアモンド印にする	plt.plot(データ列, データ列2, marker='D')
nがn2より大きい	n > n2
ファイルを閉じる	f.close()
UTF8でファイルを書き込み用にオープンする]	open(filepath, mode='w', encoding='utf-8')
＜オプション＞ダークグレー色を使う	color = 'darkgrey'
イテラブルと配列で濃いグラフを描画して、その線幅をnにする	plt.plot(xdata, ydata, linestyle='deep', color='r')
タイムスタンプデータが何秒か知る	aDatetime.second
データフレームの列が正規表現文字列にマッチしないデータを選ぶ	df[not df[column].str.match(s)]
ヒストグラムを描画して、その色をピーチパフに設定する	plt.hist(データ列, color='peachpuff')
文字列中にひとつでも非大文字が含まれるかどうか確認する	any(not c.isupper() for c in s)
'A'列の値でデータフレームをまとめた表を使う	df.groupby('A')
マップのキーとそのエントリをペアとして取り出す	aDict.items()
折れ線グラフの星マーカーを赤くする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='r')
ヒストグラムのビン数を設定する	plt.hist(データ列, bins=n)
データフレームのそれぞれのグループの個数	df.groupby(column).count()
折れ線グラフの色をミッドナイトブルーに設定する	plt.plot(データ列, データ列2, color='midnightblue')
ヒストグラムを描画して、その色をダークグレーに変更する	plt.hist(データ列, color='darkgrey')
数列とリストについての散布図にカラーコードの丸マーカーを描く	plt.plot(xdata, ydata, marker='o', c=rgb)
イテラブルをカウントして、カウンタを更新する	aCounter.update(iterable)
データ列とラベル列を指定して、積み上げ棒グラフを描画する	"plt.bar(ラベル列, データ列, bottom=データ列2, color=""red"")"
データフレームのカラムの平均値	df[col].mean()
空のタプルを作る	()
データフレームの列が文字列で始まらない行を抽出する	df[not df[column].str.startswith(s)]
xが真かどうか調べる	bool(x)
ヒストグラムを描画して、色をモカシンに設定する	plt.hist(データ列, color='moccasin')
折れ線グラフを描画して、その色をスノーに設定する	plt.plot(データ列, データ列2, color='snow')
＜オプション＞グラフの色をシルバーに指定する	color = 'silver'
データフレームを複数の列を用いて大きい順に破壊的に並べ直す	df.sort_values(by=column, ascending=False, inplace=True)
降順に破壊的に二つの列によってデータフレームをソートする	df.sort_values(by=['A', 'B'], ascending=False, inplace=True)
キーが辞書に存在するか調べる	key in aDict
データフレームのリストカラムのどの値が頻出か確認する	df[aList].mode()
折れ線グラフを描画して、その色をシアンに設定する	plt.plot(データ列, データ列2, color='cyan')
データフレームのリストカラムの欠損値を直前の値に設定する	df[aList].fillna(method='ffill')
配列とリストについて色差別ない色の折れ線を描いて、その線幅をnにセットする	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データフレームに重複があるか見る	df.duplicated()
データフレームの中の列を等量でn個にビン分割する	pd.qcut(df[col], n)
Pandasで、データフレームのカラムをインデックスにする	df.set_index(col, inplace=True)
イテラブルを累積した列	itertools.accumulate(iterable, operator.mul)
＜オプション＞スノーにグラフの色を設定する	color = 'snow'
二つの浮動小数点数が近似値	math.isclose(x, x2)
無限にカウントアップする	itertools.count()
最初のコマンド引数	sys.argv[1]
配列の次元数	aArray.ndim
整数nの二進文字列	bin(n)[2:]
ヒストグラムを描画して、その色をライムに設定する	plt.hist(データ列, color='lime')
データフレームのリストカラムを1000の位で丸める	df[aList].round(-3)
データ列を10の位で丸めて、整数型にする	ds.round(-1).astype(int)
折れ線グラフを描画して、その色をフクシアに設定する	plt.plot(データ列, データ列2, color='fuchsia')
＜オプション＞スキップするフッタをnに設定する	skipfooter = n
二つの表データを異なる列をキーにして外部ジョインする	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
濃いとしてヒストグラムを描く	plt.hist(xdata, color='deep')
ヒストグラムを描画して、その色をフローラルホワイトに設定する	plt.hist(データ列, color='floralwhite')
モカシンにヒストグラムの色を変更する	plt.hist(データ列, color='moccasin')
ヒストグラムでデータ列を可視化する	plt.hist(ds)
折れ線グラフの色をミッドナイトブルーに変更する	plt.plot(データ列, データ列2, color='midnightblue')
ホワイトスモーク色のヒストグラムを描画する	plt.hist(データ列, color='whitesmoke')
要素ひとつのりストを作る	[element]
ヒストグラムを描画して、その色を赤に設定する	plt.hist(データ列, color='red')
整数nがリストのどれかか調べる	n in aList
データフレームのカラムを10の位で丸める	df[col].round(-1)
折れ線グラフの色をネイビーに設定する	plt.plot(データ列, データ列2, color='navy')
データフレームの列の欠損値を前の行の値に設定する	df[col].fillna(method='ffill')
キューをリストに変換する	list(deq)
クラスが名前付きタプルか調べる	issubclass(C, tuple)
二変数の最も大きい値	max(x, y)
方程式として数式の変数の解を求める	sympy.solve(e, z)
モカシンにヒストグラムの色を指定する	plt.hist(データ列, color='moccasin')
UNIX秒の文字列から日付データに変換する	pd.to_datetime(s, unit='s', utc=True)
文字列は組に含まれるかどうか調べる	element in aTuple
データフレームの列をドロップして、入れ替える	df.drop(column, axis=1, inplace=True)
文字列をバイト列に変換する	s.encode(encoding='utf-8', errors='strict')
＜オプション＞ダークゴールデンロッド色を使う	color = 'darkgoldenrod'
折れ線グラフを描画してその色を青に変更する	plt.plot(データ列, データ列2, color='blue')
＜オプション＞バリーウッド色を使用する	color = 'burlywood'
ヒストグラムを描画して、アルファ値をxに変更する	plt.hist(データ列, alpha=x)
本日をタプルに変換する	datetime.datetime.today().timetuple()
クラスが名前付きタプル	issubclass(C, tuple)
複数行対応としてパターンを事前にコンパイルする	re.compile(pattern, flag=re.MULTILINE)
ヒストグラムを描画して、その色をオレンジに設定する	plt.hist(データ列, color='orange')
オブジェクトにフィールドが存在するかどうか	hasattr(obj, プロパティ名)
ファイルが存在しない	not os.path.exists(filepath)
グラフの描画で淡いカラーパレットを使う	sns.set(pallete='muted')
プロットの横軸にuntitledというラベルを付ける	plt.xlabel(untitled)
イテラブルからカウンタを作る	collections.Counter(iterable)
リストのn番目からn2番目の部分	aList[n:n2]
nがn2未満、またはn3以上かどうか調べる	n < n2 or n >= n3
タプルの要素を昇順に並べ直す	sorted(aTuple, reverse=False)
データフレームの中に文字列と文字列がいくつあるか数える	df.isin([value, value2]).sum()
リストと配列について散布図をプロットして、マーカーを菱形に設定する	plt.plot(xdata, ydata, marker='D')
文字列中にひとつでも非英数字があるか判定する	any(not c.isalnum() for c in s)
平均でデータフレームの未入力値を埋める	df.fillna(df.mean())
文字列をバイト配列に変換する	bytearray(s)
データフレームを丸める	df.round()
色差別ない色のマーカーを使って散布図を描画する	plt.plot(xdata, ydata, c='colorblind')
リストとリストの明るいグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='bright', color='b')
ヒストグラムを描画してその色をライトサーモンにセットする	plt.hist(データ列, color='lightsalmon')
配列とデータ列について散布図を描画して、マーカーを右三角に設定する	plt.plot(xdata, ydata, marker='>')
ふたつの集合の対称差集合	aSet.symmetric_difference(aSet2)
データフレームの指定された2つの列のみ取り出す	df[[column, column2]]
印字を全部求める	string.printable
線グラフを描画して、その色をアリスブルーに設定する	plt.plot(データ列, データ列2, color='aliceblue')
数を万の位で四捨五入する	round(x, -4)
標準出力の出力先がターミナルか	os.isatty(sys.stdin.fileno())
整数が正の数かどうか	x > 0
＜オプション＞エンコーディングを文字列の示すエンコーディングに設定する	encoding = s
nまたはn2	n or n2
データフレームの中の列をビン数nでビン分割する	pd.cut(df[col], n)
データフレームの列の欠損値を平均で補う	df[col].fillna(df[col].mean())
ヒートマップとしてデータフレームの列と列の相関行列をグラフ化する	sns.heatmap(df[[column, column2]].corr())
＜オプション＞色をミディアムターコイズにする	color = 'mediumturquoise'
データ列を折れ線グラフに描画して、マーカーをバツ印にする	plt.plot(データ列, データ列2, marker='x')
データ列を中央値でビン分割する	pd.qcut(ds, 2)
＜オプション＞ライトゴールドロディイエロー色を使用する	color = 'lightgoldenrodyellow'
リストとリストについての散布図を大きさnで描画する	plt.scatter(xdata, ydata, s=n)
折れ線グラフに赤い下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='r')
インデックスによって昇順にデータフレームをソートする	df.sort_index(ascending=True)
＜オプション＞ミディアムスプリンググリーン色を用いる	color = 'mediumspringgreen'
リストとリストについて散布図を描画して、マーカーをバツに設定する	plt.plot(xdata, ydata, marker='x')
不揃いな長さののzip	itertools.zip_longest(iterable, iterable2)
浮動小数点数を三乗する	x ** 3
データフレームの未入力値を平均値で置き換える	df.fillna(df.mean())
プラットホームのバイトオーダを知る	sys.byteorder
数列とデータ列について散布図を描画して、色を色差別ないに指定する	plt.plot(xdata, ydata, c='colorblind')
文字列がn回繰り返すイテラブル	itertools.repeat(element, n)
nからn2の値を引いてnにする	n -= n2
データフレームの欠損値を平均に指定する	df.fillna(df.mean())
＜オプション＞ブルーバイオレット色を使う	color = 'blueviolet'
ヒストグラムの色を黄色くする	plt.hist(データ列, color='y')
アルファベットを全部見る	string.ascii_letters
異なる列をキーにして二つのデータフレームを右ジョインする	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
カラーコードの右三角マーカーをデータ列とリストの散布図に描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
シエナ色のヒストグラムを描画する	plt.hist(データ列, color='sienna')
0から始まる無限数列	itertools.count()
オブジェクトのプロパティの値を値に設定する	setattr(obj, プロパティ名, 値)
オブジェクトは浮動小数点数クラスのインスタンスかどうか確認する	isinstance(obj, float)
逆双曲線正弦	math.asinh(x)
グラフの描画で色差別ない色を使う	sns.set(pallete='colorblind')
プラットフォームの文字コードの最大値	sys.maxunicode
イテラブルを集合にする	set(iterable)
＜オプション＞淡いピンク色色を使用する	color = 'lightpink'
本日の年	datetime.datetime.today().year
折れ線グラフに青いダイアモンド印を描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='b')
数式を因数分解する	sympy.factor(e)
ファイル名がテキストファイルか調べる	filename.endswith('.txt')
文字列を部分文字列で二つに分ける	s.partition(sub)
線グラフを描画して、色をミディアムスプリンググリーンに変更する	plt.plot(データ列, データ列2, color='mediumspringgreen')
＜オプション＞スラッシュをセパレータで用いる	sep = '/'
日付時刻データにn分分、加算する	aDatetime + datetime.timedelta(minutes=n)
文字列を緑色で表示できる文字列に変換する	f'\033[32m{value}\033[0m'
配列とリストの散布図を描画して、マーカーを三角に変更する	plt.plot(xdata, ydata, marker='^')
nをn2分の一にする	n /= n2
リストをn回、接続する	aList * n
赤い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='r')
ヒストグラムを描画して、その色をカデットブルーに設定する	plt.hist(データ列, color='cadetblue')
ヒストグラムの色をコーラルに設定する	plt.hist(データ列, color='coral')
＜オプション＞符号なし８ビット整数型を使う	dtype = np.uint8
線グラフの色をパールバイオレットレッドに変更する	plt.plot(データ列, データ列2, color='palevioletred')
両端キューが空か調べる	len(deq) == 0
数式を浮動小数点数に変換する	float(e)
データフレームを各列と列の組み合わせ毎にグループ化して、最小値を求める	df.groupby([column, column2], as_index=False).min()
折れ線グラフに黄色い星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='y')
＜オプション＞グラフの色をラベンダーブラッシュに指定する	color = 'lavenderblush'
線グラフの色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
データフレームの内の列と列に重複があれば削除する	df.drop_duplicates(subset=[column, column2])
文字列を最後の部分文字列で分けたときの後半の文字列	s.rpartition(sub)[-1]
データフレームの重複した行をマスクする	df.duplicated()
範囲を指定して整数乱数を生成する	random.randint(最小値, 最大値)
＜オプション＞グレー色を使う	color = 'grey'
＜オプション＞グラフの色を淡いピンク色に設定する	color = 'lightpink'
数式を簡略にする	sympy.sympify(e)
＜オプション＞大バツマーカーを描画する	marker = 'X'
正規分布として乱数を生成する	random.normalvariate(mu=0.5, sigma=0.2)
両端キューのstart〜endの部分値	collections.deque(itertools.islice(deq, start, end))
折れ線グラフの右三角マーカーを黄色くする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='y')
折れ線グラフに大きさnの▲マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markersize=n)
リストの各要素を関数に適用した結果でソートする	sorted(aList, key=func)
ファイルを書き込みモードでオープンする]	open(filepath, mode='w')
タプルをJSON形式でファイルに保存する	json.dump(aDict, fout, ensure_ascii=False)
三つのデータフレームを横方向に連結する	pd.concat([df, df2, df3], axis=1)
青紫色の折れ線グラフを描画する	plt.plot(データ列, データ列2, color='violet')
ふたつの集合のユニオン	aSet.union(aSet2)
色差別ない色の折れ線を描画してその線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データフレームのカラムがどの程度、分散しているか見る	df[col].var()
標準エラーを用いる	sys.stderr
リストとリストについて黒い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
データフレームを各列と列の組み合わせ毎にグループ化して、最大値を求める	df.groupby([column, column2], as_index=False).max()
リストとリストのカラーコードの色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
データフレームを列によってによって破壊的にソートする	df.sort_values(by=column, inplace=True)
データフレームの列が文字列が含まれない行を抽出する	df[not df[column].str.contains(s)]
日付データにn週間分、加算する	aDate + datetime.timedelta(weeks=n)
イテラブルとデータ列について散布図を描画してマーカーを下三角に指定する	plt.plot(xdata, ydata, marker='v')
折れ線グラフの大バツ印の線幅をnに指定する	plt.plot(データ列, データ列2, marker='X', markeredgewidth=n)
両端キューの要素を左にn個分ローテンションする	deq.rotate(-n)
リストとリストについて明るい色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
折れ線グラフを描画してその色を茶色に設定する	plt.plot(データ列, データ列2, color='brown')
リストとリストについて明るい色の折れ線グラフを描いてその線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
文字列を下線付きでプリントできる文字列に変換する	f'\033[4m{value}\033[0m'
折れ線グラフの色を紺に指定する	plt.plot(データ列, データ列2, color='darkblue')
線グラフを描画して色をプラムに設定する	plt.plot(データ列, データ列2, color='plum')
文字列の示すエンコーディングで既存のファイルパスを追加できるように開く]	open(filepath, mode='a', encoding=s)
データフレームを'A'列でソートし、、更新する	df.sort_values(by='A', inplace=True)
赤いダイアモンドマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='D', c='r')
ヒストグラムの色をダークシアンに設定する	plt.hist(データ列, color='darkcyan')
文字列を左寄せにする	s.ljust(文字列幅)
線グラフの色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategrey')
文字列を日付時刻にする	datetime.datetime.fromisoformat(日付の書かれた文字列)
浮動小数点数の有理数近似	q.limit_denominator(max_denominator=1000000)
リストを展開してプリントする	print(*aList)
文字列の先頭で複数行対応として正規表現にマッチさせる	re.match(pattern, s, flags=re.MULTILINE)
グラフの中のy軸にuntitledという軸ラベルを付ける	plt.ylabel(untitled)
星マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='*')
リストと配列について暗いを描いて、その色を黒色に設定する	plt.plot(xdata, ydata, linestyle='dark', color='k')
＜オプション＞グラフの色を青緑に設定する	color = 'teal'
線グラフの色をスレートブルーにセットする	plt.plot(データ列, データ列2, color='slateblue')
双曲線正弦の逆数	math.asinh(x)
折れ線グラフを描画して、その色をグレーに設定する	plt.plot(データ列, データ列2, color='grey')
データフレームのカラムのNaNを前の値で埋める	df[col].fillna(method='ffill')
淡いグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
＜オプション＞ダークスラテグレーにグラフの色を設定する	color = 'darkslategray'
折れ線グラフを描画して色をオリベドラブに設定する	plt.plot(データ列, データ列2, color='olivedrab')
黒い大バツマーカーとして散布図をプロットする	plt.plot(xdata, ydata, marker='X', c='k')
データフレームの空文字を欠損値に変換し、ドロップする	df.replace('', np.nan).dropna()
カウンタを少ない順に列挙する	aCounter.most_common()[::-1]
＜オプション＞シャルトリューズ色を使う	color = 'chartreuse'
値がセットのメンバーでないかどうか確認する	element not in aSet
ファイルをオープンする]	open(filepath)
数式の積分を計算する	sympy.integrate(e)
xが一桁の正の整数	0 <= x <= 9
標準入力から1文字だけ読む	sys.stdin.read(1)
ヒストグラムを描画してその色をパレットトルコイズに変更する	plt.hist(データ列, color='paleturquoise')
項目名がマップにあるか	key in aDict
カラーコードの三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
折れ線グラフを描画して、その色をレベッカパープルに設定する	plt.plot(データ列, データ列2, color='rebeccapurple')
集合の要素数	len(aSet)
文字列からformatのパターンとしてタイムスタンプに変換する	datetime.datetime.strptime(日付の書かれた文字列, format)
＜オプション＞ライトグリーンにグラフの色を設定する	color = 'lightgreen'
nが無限に続くイテラブルを得る	itertools.repeat(n)
実数が無限大	math.isinf(x)
ヒストグラムを描画してその色をコーンフラワーブルーに設定する	plt.hist(データ列, color='cornflowerblue')
日付時刻データは日付時刻データと同時か調べる	aDatetime == aDatetime2
リストとリストについての散布図にカラーコードの▽マーカーを描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
グラフの中の縦軸にuntitledというラベルを付ける	plt.ylabel(untitled)
フローラルホワイト色の線グラフを描画する	plt.plot(データ列, データ列2, color='floralwhite')
データフレームのリスト列の中に日付データがあるか判定する	df[aList].isin([value])
集合の要素が別のセットに含まれるか判定する	aSet.issubset(aSet2)
オブジェクトが文字列クラスかどうか調べる	isinstance(obj, str)
浮動小数点数に実数を加算する	x + y
暗い色の折れ線グラフを描画し、、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
実数のkを底とする対数を求める	math.log(x, k)
データフレームの中の欠損値を削除する	df.dropna()
日付データををn時間後に進める	aDate + datetime.timedelta(hours=n)
データフレームの列と列の相関行列スピアマンで	df[[column, column2]].corr(method='spearman')
プログラムの実行を強制的に終了する	sys.exit()
nが5で割り切れるか調べる	n % 5 == 0
データフレームを各列毎にグループ化して列の分散を求める	df.groupby(column)[column2].var()
データフレームの列のpercent分位数	df[col].quantile(percent/100)
パステル調のの折れ線を描き、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
折れ線グラフのマーカーをバツにする	plt.plot(データ列, データ列2, marker='x')
文字列の右側から改行を取り除く	s.rstrip('\n')
折れ線グラフを描画して、色をパパイヤウィップに変更する	plt.plot(データ列, データ列2, color='papayawhip')
日付時刻データの曜日を求める	aDatetime.weekday()
配列と数列について暗いグラフを描画し、色を青くする	plt.plot(xdata, ydata, linestyle='dark', color='b')
最初のプログラムを書く	print('Hello World')
折れ線グラフを描画して、その色をドジャーブルーに設定する	plt.plot(データ列, データ列2, color='dodgerblue')
タプルの要素を関数に適用した結果で並べる	sorted(aTuple, key=func)
＜オプション＞グラフの色をカデットブルーに変更する	color = 'cadetblue'
タプルが少なくともひとつ真か確認する	any(aTuple)
列の要素を全て集合に追加する	aSet.update(iterable)
折れ線グラフに青いバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='b')
データフレームの中で列と列の重複を削除する	df.drop_duplicates(subset=[column, column2])
行列の列ごとの分散	np.var(aArray, axis=0)
ライトグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightgray')
日付データが金曜日か	aDate.weekday() == 4
数値を緑色にする	f'\033[32m{value}\033[0m'
折れ線グラフに赤い四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='r')
折れ線グラフの色をカラーコードに設定する	plt.plot(xdata, ydata, color=rgb)
正弦を算出する	math.sin(x)
リストと配列についての散布図をパステル調の色として重なりを見やすくプロットする	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
オブジェクトが名前付きタプル型か調べる	hasattr(obj, '_asdict') and hasattr(obj, '_fields')
リストとリストを用いて暗いグラフを描いて、線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
文字列全体が正規表現にマッチするか見る	re.fullmatch(pattern, s)
イテラブルとイテラブルをペアリングする	itertools.zip_longest(iterable, iterable2)
折れ線グラフのポイント印を青くする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='b')
Pandasで、dateStringを日付データにする	pd.to_datetime(dateString)
２つのデータフレームを列をキーにしてジョインする	pd.merge(df, df2, on=column)
二つのデータフレームを縦に合体させる	pd.concat([df, df2], axis=0)
折れ線グラフを描画して、色をアリスブルーにセットする	plt.plot(データ列, データ列2, color='aliceblue')
数列とリストについて散布図を描画し、右三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='>', c=rgb)
ヒストグラムを描画して、色を黄色くする	plt.hist(データ列, color='y')
要素がマッピングの値に含まれていないかどうか調べる	element not in aDict.values()
プロットの用途を画面にする	sns.set(context='notebook')
マッピングのキーを列挙する	aDict.keys()
重複した行のみを取り出す	df[df.duplicated(keep=False)]
＜オプション＞青紫を用いる	color = 'violet'
折れ線グラフを描画して、その色をシーグリーンに設定する	plt.plot(データ列, データ列2, color='seagreen')
折れ線グラフを描画して、色をレベッカパープルに変更する	plt.plot(データ列, データ列2, color='rebeccapurple')
リストをn個にビニングして、namesのラベルをつける	pd.cut(aList, n, labels=names)
最初の列をデータフレームから除く	df[df.columns[1:]]
リストをタプルに変換する	tuple(aList)
グラフのカラーパレットを濃くする	sns.set(pallete='deep')
配列とリストについての散布図に右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>')
データフレームの内で、列とカラムの重複を調べる	df.duplicated(subset=[column, column2])
＜オプション＞グラフの色をフローラルホワイトに設定する	color = 'floralwhite'
本日の年数を見る	datetime.datetime.today().year
散布図にバツマーカーを使う	plt.plot(xdata, ydata, marker='x')
折れ線グラフを描画してその色をライトコーラルに設定する	plt.plot(データ列, データ列2, color='lightcoral')
xが1、もしくは2か調べる	x == 1 or x == 2
ファイルから拡張子なしのファイル名を使う	os.path.splitext(os.path.basename(filepath))[0]
ライトコーラル色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightcoral')
シーケンスを2回あわせた直積	itertools.product(iterable, repeat=2)
グラフをスライド用に指定する	sns.set(context='talk')
角度のラジアン	math.radians(degree)
リストとデータ列についての散布図に赤い左三角マーカーを描く	plt.plot(xdata, ydata, marker='<', c='r')
ファイルを全部読み込む	f.read()
リストとリストについての散布図を淡い色で描画する	plt.plot(xdata, ydata, c='muted')
データ列を使う	import pandas as pd
タプルをリストに変換する	list(aTuple)
ヒストグラムの色をブランチドアーモンドに設定する	plt.hist(データ列, color='blanchedalmond')
行列の値	aArray[行番号, 列番号]
カラムの欠損値を平均に設定する	ds.fillna(ds.mean())
実線ヒストグラムを描画する	plt.hist(データ列, linestyle='solid')
ゴールデンロッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='goldenrod')
データフレームの欠損値を最小値に指定する	df.fillna(df.min())
折れ線グラフのダイアモンドマーカーを黒くする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='k')
ヒストグラムを描画してその色をパパイヤウィップに変更する	plt.hist(データ列, color='papayawhip')
三つの文字列を順にプリントする	print(value, value2, value3)
データフレームから指定された４つの列を抽出する	df[[column, column2, column3, column4]]
データ列のNaNをxで補う	ds.fillna(x)
列の各データが何回出現するか見る	ds.value_counts()
ヒストグラムの色をレベッカパープルに設定する	plt.hist(データ列, color='rebeccapurple')
文字列を新しい文字列で置換する	s.replace(sub, newsub)
リストと数列について散布図を描画し、、マーカーを丸に設定する	plt.plot(xdata, ydata, marker='o')
文字列のn番目	s[n]
＜オプション＞オリーブ色を使う	color = 'olive'
日付時刻データが日付時刻データと同時か調べる	aDatetime == aDatetime2
Pandasで、エポック秒のデータフレームのcollから日付データに変換する	pd.to_datetime(df[col], unit='s', utc=True)
インデント付きで辞書を文字列に変換する	json.dumps(aDict, ensure_ascii=False, indent=n)
複数列の散布図を一度に描画する	sns.pairplot(df[[column, column2, column3]])
行列のユニークな要素とその個数	u, counts = np.unique(aArray, return_counts=True)
折れ線グラフに緑色のダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='g')
線グラフを描画して、色をミントクリームに設定する	plt.plot(データ列, データ列2, color='mintcream')
明るいグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='bright', color='r')
右三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='>')
集合から別の集合の要素を除く	aSet.difference_update(aSet2)
＜オプション＞ダークカーキを使う	color = 'darkkhaki'
実数を十六進文字列にする	x.hex()
データフレームの列のヒストグラムをプロットする	plt.hist(df[column])
黒色のクロスマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x', c='k')
ファイルパスをBOM付きで書き込み用にオープンする]	open(filepath, mode='w', encoding='utf_8_sig')
ひとつ飛ばしでタプルを抽出する	aTuple[::2]
折れ線グラフの星印を赤くする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='r')
xを印字できる文字列にする	ascii(x)
文字列がタプルの要素か調べる	element in aTuple
一点鎖線グラフを描画する	plt.plot(データ列, データ列2, linestyle='dashbot')
セットをイミュータブルに変換する	frozenset(aSet)
リストとデータ列として明るいを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
集合を空にする	aSet.clear()
エクセルファイルファイルからn番目のシートをデータフレームとして読み込む	pd.read_excel(filename, sheet_name=n)
データ列が何月か見る	ds.dt.month
両端キューのstart番目からend番目の部分要素	collections.deque(itertools.islice(deq, start, end))
自然数最小公倍数	math.lcm(n, n2)
コーンズシルク色の線グラフを描画する	plt.plot(データ列, データ列2, color='cornsilk')
0からNまでの配列を作る	np.arange(N)
赤色の大バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='X', c='r')
データフレームのNaNをxで埋める	df.fillna(x)
日付データををn分後に進める	aDate + datetime.timedelta(minutes=n)
データフレームの末尾を確認する	df.tail()
整数個からk個取り出したときの順列の総数	math.perm(n, k)
データフレームとデータ列を横方向に連結する	pd.concat([df, ds], axis=1)
ヒストグラムを描画して、その色をブランチドアーモンドに設定する	plt.hist(データ列, color='blanchedalmond')
列によってデータフレームを集計してそれぞれのグループの標準偏差を計算する	df.groupby(column).std()
nがn2より大きいか	n > n2
日付データを文字列を用いてフォーマットする	"aDate.strftime(""%d/%m/%y"")"
折れ線グラフを描画してその色をダークグレーに変更する	plt.plot(データ列, データ列2, color='darkgray')
スライドにプロットの目的を指定する	sns.set(context='talk')
項目名ワード引数でマッピングに更新する	aDict.update(**kwargs)
黒いヒストグラムを描画する	plt.hist(データ列, color='k')
データフレームの各グループ毎の合計を求める	df.groupby(column).sum()
ファイルパスからバイナリ書き込みストリームをオープンして]fとする	f = open(filepath, mode='wb')
＜オプション＞グラフの色をバリーウッドに指定する	color = 'burlywood'
リストとリストのパステル調のグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
'A'列をキーにしてデータフレームを並べ直す	df.sort_values(by='A')
1からNまでの配列	np.arange(1, N+1)
データ列のNaNを最小値で埋める	ds.fillna(ds.min())
グラフの色を全般的に濃くする	sns.set(pallete='deep')
リストとリストの黒い淡いグラフを描く	plt.plot(xdata, ydata, linestyle='muted', color='k')
文字列の中のASCII限定として正規表現による全てのマッチを使う	re.findall(pattern, s, flags=re.ASCI)
カラーコードの四角マーカーをリストとリストについての散布図に描く	plt.plot(xdata, ydata, marker='s', c=rgb)
変数をシアンでプリントする	print(f'\033[36m{value}\033[0m')
破壊的に列によってでデータフレームをソートする	df.sort_values(by=column, inplace=True)
リストとリストについて散布図を描画し、、色を濃いに設定する	plt.plot(xdata, ydata, c='deep')
日付データからn週間分減らす	aDate - datetime.timedelta(weeks=n)
データフレームを1000の位で丸める	df.round(-3)
プラム色の線グラフを描画する	plt.plot(データ列, データ列2, color='plum')
折れ線グラフを描画して、その色をミディアムブルーに設定する	plt.plot(データ列, データ列2, color='mediumblue')
ファイル全体を行単位で分割して読み込む	f.readlines()
データフレームから破壊的に重複を削除する	df.drop_duplicates(inplace=True)
整数nの二進表現	bin(n)
三自然数のGCD	math.gcd(n, n2, n3)
データフレームの列がxより少ないデータを取り出す	df[df[column] < x]
データフレームのそれぞれのグループごとの標準偏差を計算する	df.groupby(column).std()
データ列が何秒か見る	ds.dt.second
カラーマップでヒストグラムを描画する	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
eの乗数	math.exp(x)
xの印字可能な文字列	ascii(x)
タプル中の要素が全て真	all(aTuple)
整数の並べ方の総数を算出する	math.perm(n)
リストとリストを連結する	aList + aList2
＜オプション＞グラフの色をミディアムスレートブルーに設定する	color = 'mediumslateblue'
＜オプション＞タブを区切りで使う	sep = '\t'
xを浮動小数点数型に変換する	float(x)
＜オプション＞グラフの線種を一点鎖線に設定する	linestyle = 'dashbot'
文字列の開始位置から部分文字列を探す	s.find(sub, start)
折れ線グラフの色をオールドレースに設定する	plt.plot(データ列, データ列2, color='oldlace')
ヒストグラムの色をパールバイオレットレッドに設定する	plt.hist(データ列, color='palevioletred')
散布図にカラーコードのポイントマーカーを使う	plt.plot(xdata, ydata, marker='.', c=rgb)
＜オプション＞ネイビー色を用いる	color = 'navy'
赤いダイアモンドマーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='D', c='r')
データ列の文字列を未入力値に変換する	ds.replace(s, np.nan)
日付データが何月か知る	aDate.month
リストとリストについての散布図に下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v')
＜オプション＞グラフの色をクリムゾンに設定する	color = 'crimson'
データフレームを各列と列の組み合わせ毎にグループ化して最小値を求める	df.groupby([column, column2], as_index=False).min()
TSVファイルからCSVをSJISで読む	pd.read_csv(filename, encoding='shift_jis')
小さい順に'A'列によってデータフレームを整列して、更新する	df.sort_values(by='A', ascending=True, inplace=True)
色差別ない色の折れ線を描画し、、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データ列のNaNをxに指定する	ds.fillna(x)
＜オプション＞スプリンググリーン色を用いる	color = 'springgreen'
データ列の曜日が何日目か見る	ds.dt.dayofweek
リストとリストの青い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='b')
リストとリストについて散布図を描画して、文字列という凡例用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
ネイビー色の線グラフを描画する	plt.plot(データ列, データ列2, color='navy')
赤い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='r')
文字列内に数字があるかどうか調べる	any(c.isdigit() for c in s)
＜オプション＞欠損値は無視する	dropna = True
オブジェクトはバイト列クラスか調べる	isinstance(obj, bytes)
ファイルを改行を取り除いて一行ずつ読む	f.readline()
バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x')
リストと配列で折れ線を描画して、その線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n)
データ列とラベル列を指定して、横棒グラフを描画する	plt.barh(ラベル列, データ列)
実数を複素数に変換する	complex(x)
日付時刻データからn週間を減らす	aDatetime - datetime.timedelta(weeks=n)
ヒストグラムを描画して、その色をライトサーモンに設定する	plt.hist(データ列, color='lightsalmon')
データフレームを10の位で四捨五入して整数型にする	df.round(-1).astype(int)
データフレームのカラムを10の位で丸めて、整数型にする	df[col].round(-1).astype(int)
グラフに凡例を文字列と文字列と入れる	plt.legend([s, s2])
データフレームの列がリストに含まれる行を取り出す	df[df[column].isin(aList)]
データフレームの列の中に文字列と文字列があるかどうか	df[col].isin([value, value2])
リストとリストの色差別ないグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
xとyの商と余りを同時に算出する	divmod(x, y)
ミディアムオーキッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumorchid')
＜オプション＞タブをセパレータで使う	sep = '\t'
ビン数nを用いてデータフレームの中のカラムをビン分割してnamesのラベルをつける	pd.cut(df[col], n, labels=names)
配列をn個に分割する	pd.cut(aArray, n)
散布図を淡い色として描く	plt.plot(xdata, ydata, c='muted')
配列の列ごとの最大値	np.max(aArray, axis=0)
データフレームのカラムは何時か見る	df[col].dt.hour
散布図に赤い四角マーカーを使う	plt.plot(xdata, ydata, marker='s', c='r')
データ列とリストで濃いグラフを描いてその線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', color='r')
文字列の接頭辞から部分文字列を除く	s.removeprefix(sub)
＜オプション＞グラフの色をミディアムオーキッドに変更する	color = 'mediumorchid'
リストから文字列を取り除く	aList.remove(element)
淡いグラフを描いて、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color='r')
破線ヒストグラムを描画する	plt.hist(データ列, linestyle='dashed')
折れ線グラフを描画して色をグレーに変更する	plt.plot(データ列, データ列2, color='grey')
データフレームのカラムの値を正規表現patternでまとめてreplに置き換える	df[col].replace(pattern, repl, regex=True)
数列とリストについて破線を描画し、、色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
データ列と数列の散布図をプロットしてマーカーの色を色差別ないに設定する	plt.plot(xdata, ydata, c='colorblind')
ダークスレートブルー色のヒストグラムを描画する	plt.hist(データ列, color='darkslateblue')
Pandasのバージョンを表示する	print(pd.__version__)
紺色のヒストグラムを描画する	plt.hist(データ列, color='darkblue')
文字列内にひとつでも英字があるかどうか調べる	any(c.isalpha() for c in s)
行列の行ごとの最大値	np.max(aArray, axis=1)
線グラフを描画して、その色をグレーに設定する	plt.plot(データ列, データ列2, color='grey')
配列をy軸リストを横軸と設定して、折れ線を描画する	plt.plot(xdata, ydata)
リストから両端キューを作る	collections.deque(iterable)
＜オプション＞区切りをタブにする	sep = '\t'
データフレームを二つの列によって降順に破壊的にソートする	df.sort_values(by=['A', 'B'], ascending=False, inplace=True)
データフレームのカラムの文字列を欠損値に変換する	df[col].replace(s, np.nan)
ヒストグラムの色をシエナに設定する	plt.hist(データ列, color='sienna')
文字列リストにイテラブルを変換して、'改行で連結する	'\n'.join(map(str, iterable))
文字列の先頭だけ大文字化する	s.capitalize()
ヒストグラムを描画して、その色をフクシアに設定する	plt.hist(データ列, color='fuchsia')
折れ線グラフを描画して、その色をカデットブルーに設定する	plt.plot(データ列, データ列2, color='cadetblue')
赤い大バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='X', c='r')
値を黒色化する	f'\033[30m{value}\033[0m'
折れ線グラフの色をカーキに変更する	plt.plot(データ列, データ列2, color='khaki')
ゼロ埋めされた８ビット整数型の配列を作る	np.zeros(要素数, dtype=np.int8)
リストとリストについて散布図を描画して、バツマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='x', c=rgb)
折れ線グラフにサイズnの下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markersize=n)
＜オプション＞ミディアムスプリンググリーン色を使う	color = 'mediumspringgreen'
カウンタを高頻出方から列挙する	aCounter.most_common()
折れ線グラフの色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgrey')
列のユニークな値	ds.unique()
データフレームのリストカラムの未入力値を前の行の値に設定する	df[aList].fillna(method='ffill')
折れ線グラフに黒いポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='k')
＜オプション＞淡い茶色色を使う	color = 'tan'
折れ線グラフの星マーカーを黒くする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='k')
ファイルを追加モードを使ってオープンして]fとする	f = open(filepath, mode='a')
n割るn2の切り上げ	(n + n2 - 1) // n2
変数が0に近づく場合の数式の極限値を計算する	sympy.limit(e, z, 0)
ライム色の線グラフを描画する	plt.plot(データ列, データ列2, color='lime')
ヒストグラムを描画して、その色を黄色に設定する	plt.hist(データ列, color='yellow')
グラフにy=0の点線を付ける	plt.axhline(y=0, linestyle='dotted')
折れ線グラフにポイントマーカーを加える	plt.plot(データ列, データ列2, marker='.')
＜オプション＞グラフの色を貝殻に設定する	color = 'seashell'
＜オプション＞サーモン色を使う	color = 'salmon'
文字列中のタブ文字をn個の空白に置換する	s.expandtabs(tabsize=n)
配列の分散を求める	np.var(aArray)
無限にnからカウントダウンする	itertools.count(start=n, step=-1)
線グラフを描画して、その色をスラグレーに設定する	plt.plot(データ列, データ列2, color='slategrey')
データ列をビン数nでビン分割する	pd.cut(ds, n)
イテラブルとリストの散布図を明るい色で描画する	plt.plot(xdata, ydata, c='bright')
折れ線グラフを描画して、その色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategrey')
両端キューの最大長	deq.maxlen
配列の行ごとの最大	np.max(aArray, axis=1)
折れ線グラフの色をオリーブに設定する	plt.plot(データ列, データ列2, color='olive')
文字列を黒色にする	f'\033[30m{value}\033[0m'
列名リストによってデータフレームをソートして、更新する	df.sort_values(by=column, inplace=True)
二つの辞書を階層化する	collections.ChainMap(aDict, aDict2)
データフレームのリスト列の値が欠損値か調べる	df[aList].isna()
データフレームの列の各値の出現数	df[col].value_counts()
淡い色としてリストについてのヒストグラムをプロットする	plt.hist(xdata, color='muted')
複数の列を用いてデータフレームをソートして、NaNを先頭に来るようにする	df.sort_values(by=column, na_position='first')
数式の積分を求める	sympy.integrate(e)
JSON文字列をデータにする	json.loads(b.decode('unicode-escape'))
青い淡いを描画する	plt.plot(xdata, ydata, linestyle='muted', color='b')
＜オプション＞色を白に設定する	color = 'white'
黒い暗いを描く	plt.plot(xdata, ydata, linestyle='dark', color='k')
散布図にクロスマーカーを用いる	plt.plot(xdata, ydata, marker='x')
折れ線グラフを描画して、その色をシスルに設定する	plt.plot(データ列, データ列2, color='thistle')
列をキーとして二つのデータフレームを結合する	pd.merge(df, df2, on=column)
二次元タプルをフラット化する	sum(aTuple)
赤色のヒストグラムを描画する	plt.hist(データ列, color='red')
行列の計算をする	import numpy as np
ミディアムスプリンググリーンにヒストグラムの色をセットする	plt.hist(データ列, color='mediumspringgreen')
組内の要素は少なくとも一つ真	any(aTuple)
ランダムにデータフレームから取り出す	df.sample()
データ列を箱ひげ図にする	plt.boxplot(データ列)
ファイルからストリームをオープンして]、fileとする	file = open(filepath)
赤色のパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
折れ線グラフを点線で描画する	plt.plot(データ列, データ列2, linestyle='dotted')
折れ線グラフに左三角マーカーを使う	plt.plot(データ列, データ列2, marker='<')
x,y,zをそれぞれn,n2,n3に設定する	x, y, z = n, n2, n3
データフレームの欠損値が含まれる箇所に色を付ける	df.style.highlight_null()
＜オプション＞グラフの色をライムグリーンに設定する	color = 'limegreen'
折れ線グラフの色をダークグリーンに設定する	plt.plot(データ列, データ列2, color='darkgreen')
両端キューが空でないか調べる	len(deq) != 0
ふたつの辞書を合体する	aDict | aDict2
二つの列によってデータフレームをグループ化し、要約統計量を算出する	df.groupby(['A', 'B']).describe()
リストとリストについての散布図を淡い色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='muted', alpha=0.5)
改行なしに２つの変数をプリントする	print(value, value2, end='')
＜オプション＞グラフの色をライトイエローに設定する	color = 'lightyellow'
リストに応じて、散布図の色を変える	plt.scatter(xdata, ydata, c=aList, cmap='Blues')
実数とyの斜辺	math.hypot(x, y)
折れ線グラフの色をダークシアグリーンに指定する	plt.plot(データ列, データ列2, color='darkseagreen')
プロットの中の縦軸に軸名を設定する	plt.ylabel(untitled)
データフレームをカラムによって集約してそれぞれのグループ毎の最小値を算出する	df.groupby(column).min()
折れ線グラフを描画して、その色をコーンフラワーブルーに設定する	plt.plot(データ列, データ列2, color='cornflowerblue')
データフレームの歪度	df.kurt()
暗い色の折れ線グラフを描画して、その線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
＜オプション＞グラフの色をプラムに設定する	color = 'plum'
データフレームの列の欠損値を直前の値で補う	df[col].fillna(method='ffill')
データフレームのリストカラムのどの値が頻出か見る	df[aList].mode()
カラーコードの四角マーカーを散布図に使う	plt.plot(xdata, ydata, marker='s', c=rgb)
文字列の両端から空白と改行を除く	s.strip()
既存のベクトルをベースに全要素が初期値の配列	np.full_like(aArray, 初期値)
数式のn階微分を計算する	sympy.diff(e, z, n)
深紅色の線グラフを描画する	plt.plot(データ列, データ列2, color='crimson')
データフレームを列によって昇順に破壊的にソートする	df.sort_values(by=column, ascending=True, inplace=True)
キーがマッピングに存在するかどうか調べる	key in aDict
ヒストグラムを描画して、その色をダークターコイズにする	plt.hist(データ列, color='darkturquoise')
濃いの折れ線グラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
全てのシートをエクセルファイルファイルから読み込む	pd.read_excel(filename, sheet_name=None)
ファイルパスから拡張子なしのファイル名を使う	os.path.splitext(os.path.basename(filepath))[0]
nから無限にカウントダウンする	itertools.count(start=n, step=-1)
折れ線グラフの△マーカーを緑色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='g')
0から始まるn個の整数列	list(range(n))
折れ線グラフを描画して、その色をタンに設定する	plt.plot(データ列, データ列2, color='tan')
リストとリストについて暗い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
＜オプション＞コロンをセパレータで使う	sep = ':'
数の小数点以下を丸める	round(x)
リストをy軸、リストを横軸として、大きさnの散布図を描く	plt.scatter(xdata, ydata, s=n)
ファイルをBOM付きとしてオープンする]	open(filepath, encoding='utf_8_sig')
リストとリストの黒いパステル調のを描く	plt.plot(xdata, ydata, linestyle='pastel', color='k')
青紫色の線グラフを描画する	plt.plot(データ列, データ列2, color='violet')
折れ線グラフを描画して、その色をミッドナイトブルーに設定する	plt.plot(データ列, データ列2, color='midnightblue')
ヒストグラムの色をパウダーブルーに設定する	plt.hist(データ列, color='powderblue')
ヒストグラムを描画して、その色をダークオリーブグリーンに指定する	plt.hist(データ列, color='darkolivegreen')
折れ線グラフの色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgray')
集合に要素を追加する	aSet.add(element)
＜オプション＞グラフの色を淡いピンク色に指定する	color = 'lightpink'
＜オプション＞どの行もヘッダにしない	header = None
リストの最後から要素をポップする	aList.pop()
リストを明るい色の柱状グラフとして描画する	plt.hist(xdata, color='bright')
データフレームの列をヒストグラムにする	plt.hist(df[column])
表データを列でグループ化し、、列挙する	[(name, group) for name, group in df.groupby(column)]
列'A'と列'B'をキーとして二つのデータフレームを結合する	pd.merge(df, df2, left_on='A', right_on='B')
リストとリストについて散布図を描画して、星マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='*', c=rgb)
タイムスタンプデータにn時間分加算する	aDatetime + datetime.timedelta(hours=n)
タプル内の要素が全て真か調べる	all(aTuple)
散布図にカラーコードの左三角マーカーを使う	plt.plot(xdata, ydata, marker='<', c=rgb)
nがn2で割り切れるか調べる	n % n2 == 0
ヒストグラムの色をベージュに設定する	plt.hist(データ列, color='beige')
破線グラフの色を淡いに変更する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
折れ線グラフの色をスカイブルーにする	plt.plot(データ列, データ列2, color='skyblue')
文字列の接尾辞から部分文字列を取り除く	s.removesuffix(sub)
パールバイオレットレッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='palevioletred')
nが偶数か調べる	n % 2 == 0
データ列の欠損値をメディアンに変更する	ds.fillna(ds.median())
折れ線グラフを描画してその色を真紅に設定する	plt.plot(データ列, データ列2, color='crimson')
点線ヒストグラムを描画する	plt.hist(データ列, linestyle='dotted')
データフレームを破壊的に複数の列によってによってソートする	df.sort_values(by=column, inplace=True)
データフレームのリストカラムの文字列を欠損値に変換する	df[aList].replace(s, np.nan)
エラーなく集合から要素を取り除く	aSet.discard(element)
サイコロと同じ乱数	random.randint(1, 6)
折れ線グラフを描画して、その色をライトゴールドロディイエローに設定する	plt.plot(データ列, データ列2, color='lightgoldenrodyellow')
コサインの逆数	math.acos(x)
列を配列にする	df[column].values
数列とデータ列の濃いを描いてその色を黒色に設定する	plt.plot(xdata, ydata, linestyle='deep', color='k')
データフレームを100の位で丸めて、整数型にする	df.round(-2).astype(int)
データフレームを列によって並べ、更新する	df.sort_values(by=column, inplace=True)
文字列がタプルに含まれるか調べる	element in aTuple
リストについてのヒストグラムを濃い色として描く	plt.hist(xdata, color='deep')
カラムを1000の位で丸める	ds.round(-3)
折れ線グラフを描画して、その色をミディアムアクアマリンに設定する	plt.plot(データ列, データ列2, color='mediumaquamarine')
データフレームのカラムの中に日付データと文字列があるか調べる	df[col].isin([value, value2])
文字列全体がパターンに複数行対応としてマッチするか確認する	re.fullmatch(pattern, s, flags=re.MULTILINE)
＜オプション＞ミディアムターコイズ色を使う	color = 'mediumturquoise'
折れ線グラフに線幅nの△マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
ヒストグラムの色をインディゴに設定する	plt.hist(データ列, color='indigo')
折れ線グラフのダイアモンドマーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
nの各桁の和	sum(map(int, str(n)))
データ列とリストについての散布図に赤い大バツマーカーを描く	plt.plot(xdata, ydata, marker='X', c='r')
リストとリストについて散布図を描画して、マーカーの色を明るいに設定する	plt.plot(xdata, ydata, c='bright')
リストと配列で色差別ないの折れ線グラフを描画して、線幅をnにセットする	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
区切りで文字列を分割して、列挙する	s.split(sep)
ヒストグラムを描画して、その色をシスルに設定する	plt.hist(データ列, color='thistle')
二つの文字列がケースを無視して同じか	s.casefold() == s2.casefold()
プラットホームがLinuxか調べる	sys.platform.startswith('linux')
＜オプション＞グラフの色をシーグリーンに設定する	color = 'seagreen'
データフレームをTSVファイルでJSONLファイルに保存する	df.to_csv(filename, sep='\t')
＜オプション＞グラフの色をターコイズに設定する	color = 'turquoise'
＜オプション＞モカシンにグラフの色を設定する	color = 'moccasin'
ファイルパスからファイル名を使う	os.path.basename(filepath)
xが真か調べる	bool(x)
＜オプション＞グラフの色をピーチパフに指定する	color = 'peachpuff'
折れ線グラフに赤い丸印を描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='r')
＜オプション＞バイナリモードを使う	mode = 'rb'
＜オプション＞パープル色を使う	color = 'purple'
列の名前を列挙する	df.columns
＜オプション＞バッファリングのサイズを設定する	buffering = 4096
＜オプション＞グラフの色をタンに設定する	color = 'tan'
データフレームから指定した２つの列を抽出する	df[[column, column2]]
nとn2の商	n / n2
数列とリストの散布図を描画して、マーカーを大バツに設定する	plt.plot(xdata, ydata, marker='X')
折れ線グラフを描画して、その色をゴーストホワイトに設定する	plt.plot(データ列, データ列2, color='ghostwhite')
実数を2乗する	x ** 2
フォレストグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='forestgreen')
Pandasで、データ列を日付データに変換する	pd.to_datetime(ds)
nをn2で割った余りをnに代入する	n %= n2
折れ線グラフに描画して、印を大バツ印にする	plt.plot(データ列, データ列2, marker='X')
ヒストグラムをプロットし、半透明化にする	plt.hist(データ列, alpha=0.5)
ドジャーブルーにヒストグラムの色を設定する	plt.hist(データ列, color='dodgerblue')
本日が土曜日か	datetime.datetime.today().weekday() == 5
辞書のキーに対応した値	aDict.get(key)
ゴーストホワイト色の線グラフを描画する	plt.plot(データ列, データ列2, color='ghostwhite')
両端キューに要素をエンキューする	deq.appendleft(element)
二つの変数をそれぞれ定義する	x, y = i, j
リストから行列を作る	np.array(aList)
カウンタの項目の出現回数	aCounter[element]
n個に等量で列をビン分割する	pd.qcut(ds, n)
データフレームを列でグループ化して、列の要約統計量を算出する	df.groupby(column).describe()[column2]
実数の平方根を求める	math.sqrt(x)
両端キューに要素をプッシュする	deq.append(element)
文字列の開始位置からと終了位置の間に部分文字列が含まれるか	s.find(sub, start, end) != -1
部分文字列か	sub in s
文字列を複数行対応として正規表現で分割する	re.split(pattern, s, flags=re.MULTILINE)
変数について数式の微分を行う	sympy.diff(e, z)
日付データにn日分、足す	aDate + datetime.timedelta(days=n)
部分文字列が部分文字列で始まるか調べる	s.startswith(sub)
折れ線グラフに丸マーカーを用いる	plt.plot(データ列, データ列2, marker='o')
散布図をバツマーカーを使って描画する	plt.plot(xdata, ydata, marker='x')
＜オプション＞ミスティローズを使う	color = 'mistyrose'
折れ線グラフを描画して、色を貝殻に設定する	plt.plot(データ列, データ列2, color='seashell')
＜オプション＞グラフの色をブラックに設定する	color = 'black'
整数nを二進文字列に変換する	bin(n)[2:]
リストの各要素に対してpredicateFuncが真であればその要素を出力する	itertools.takewhile(predicateFunc, iterable)
ヒストグラムを描画して、色をシエナに設定する	plt.hist(データ列, color='sienna')
現在処理中の例外を情報	sys.exc_info()
nを二進表記にする	bin(n)
折れ線グラフのラベルをuntitledにセットする	plt.plot(xdata, ydata, label=untitled)
タプルの文字列が最初に見つかるインデックス	aTuple.index(element)
暗い赤色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkred')
ライトスレイグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightslategray')
プロットのサイズをセットする	plt.figure(figsize=(width, height))
ヒストグラムを描画して色をダークカーキに設定する	plt.hist(データ列, color='darkkhaki')
year年month月day日hour時の日付時刻	datetime.datetime(year=year, month=month, day=day, hour=hour)
折れ線グラフの菱形印を緑色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='g')
ヒストグラムを描画して、その色をディムグレーに設定する	plt.hist(データ列, color='dimgrey')
イテラブルの集合	set(iterable)
文字列はタプルの要素か調べる	element in aTuple
ヒストグラムの色をライトサーモンに設定する	plt.hist(データ列, color='lightsalmon')
タプルの末尾のn要素を取り除く	aTuple[:-n]
配列とリストについて破線グラフを描画し、色を濃いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
数式を方程式として解く	sympy.solve(e)
折れ線グラフを描画して、その色をライトスカイブルーに設定する	plt.plot(データ列, データ列2, color='lightskyblue')
データフレームのカラムの値は欠損値か	df[col].isna()
線グラフを描画して、その色をライトグレーに設定する	plt.plot(データ列, データ列2, color='lightgrey')
折れ線グラフに黒い四角印を描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='k')
折れ線グラフを描画して、その色をオールドレースに設定する	plt.plot(データ列, データ列2, color='oldlace')
セットから別のセットとの共通要素を全て取り除く	aSet.symmetric_difference_update(aSet2)
グラフのデザインをデフォルトでいい感じに指定する	sns.set()
行列の行ごとの最小値	np.min(aArray, axis=1)
リストとイテラブルについて散布図を描画し、、マーカーを右三角に設定する	plt.plot(xdata, ydata, marker='>')
折れ線グラフの△マーカーを赤色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
データフレームのリスト列の欠損値をxで埋める	df[aList].fillna(x)
行列の行ごとの分散	np.var(aArray, axis=1)
散布図に黒い大バツマーカーを使う	plt.plot(xdata, ydata, marker='X', c='k')
ヒストグラムを描画して、その色をミディアムバイオレットレッドに指定する	plt.hist(データ列, color='mediumvioletred')
棒グラフを描画して、グラフ幅をxに設定する	plt.bar(ラベル列, データ列, width=x)
新しい文字列で正規表現にマッチした文字列を置き換える	re.sub(pattern, newsub, s)
列と列をつなぐ	itertools.chain(iterable, iterable2)
データフレームのカラムの未入力値を平均値に設定する	df[col].fillna(df[col].mean())
データフレームを使用する	import pandas as pd
データフレームのそれぞれのグループごとの最大値	df.groupby(column).max()
データ列の文字列を欠損値に変換する	ds.replace(s, np.nan)
ヒストグラムを描画して、色をライトイエローに設定する	plt.hist(データ列, color='lightyellow')
文字列の終了位置より前に部分文字列が含まれないか調べる	s.find(sub, 0, end) == -1
折れ線グラフに大きさnのポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markersize=n)
折れ線グラフを描画して、色をダークグレーに変更する	plt.plot(データ列, データ列2, color='darkgray')
データフレームをグループ化し、各列に対し個数を求める	df.groupby(column)[column2].count()
日付データをISO書式の文字列に変換する	aDate.isoformat()
チョコレート色の線グラフを描画する	plt.plot(データ列, データ列2, color='chocolate')
リストの長さだけ繰り返す	range(len(aList))
nを二進文字列に変換する	bin(n)[2:]
ロイヤルブルー色のヒストグラムを描画する	plt.hist(データ列, color='royalblue')
グラフのカラーパレットを全般的に明るくする	sns.set(pallete='bright')
文字列を小文字にする	s.casefold()
折れ線グラフの色をスプリンググリーンに設定する	plt.plot(データ列, データ列2, color='springgreen')
カラーコードのポイントマーカーを用いて散布図をプロットする	plt.plot(xdata, ydata, marker='.', c=rgb)
＜オプション＞印を下三角に変更する	marker = 'v'
ヒストグラムの色をライトシアンに設定する	plt.hist(データ列, color='lightcyan')
要素が全て初期値の配列を作る	np.full(要素数, 初期値, dtype=np.int)
ペアリストpairsからカウンタを生成する	collections.Counter(dict(pairs))
文字列の中の複数行対応として正規表現による全マッチを見る	re.findall(pattern, s, flags=re.MULTILINE)
ヒストグラムを描画して、その色をサンディーブラウンに設定する	plt.hist(データ列, color='sandybrown')
レベッカパープル色のヒストグラムを描画する	plt.hist(データ列, color='rebeccapurple')
日付データにn週間を加算する	aDate + datetime.timedelta(weeks=n)
エラーなくリストの文字列の位置を求める	aList.index(element) if element in aList else -1
ライトグレー色のヒストグラムを描画する	plt.hist(データ列, color='lightgray')
データフレームを関数の値でまとめたグループ	df.groupby(関数)
ヒストグラムの色を真紅に設定する	plt.hist(データ列, color='crimson')
日付時刻データからn分減算する	aDatetime - datetime.timedelta(minutes=n)
ヒストグラムを描画して、その色をゴールデンロッドに設定する	plt.hist(データ列, color='goldenrod')
文字列が文字列リストのいづれか調べる	s in aStringList
実数の正弦の逆数を算出する	math.asin(x)
折れ線グラフの色をシーグリーンに設定する	plt.plot(データ列, データ列2, color='seagreen')
ターコイズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='turquoise')
データフレームを二つの列によってによって破壊的にソートする	df.sort_values(by=['A', 'B'], inplace=True)
nがn2で割り切れないか調べる	n % n2 != 0
セットをタプルに変換する	tuple(aSet)
＜オプション＞色をパールゴールデンロッドにセットする	color = 'palegoldenrod'
オプションで、ファイルを使う	file = sys.open(filename, 'w')
文字列を黒色でプリントする	print(f'\033[30m{value}\033[0m')
日付データにn時間分加算する	aDate + datetime.timedelta(hours=n)
データフレームのリストカラムの中に文字列と文字列があるかどうか調べる	df[aList].isin([value, value2])
ヒストグラムを描画してその色をブランチドアーモンドにセットする	plt.hist(データ列, color='blanchedalmond')
リストと数列の折れ線グラフをカラーコードで描画する	plt.plot(xdata, ydata, color=rgb)
紺色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkblue')
八進文字列を整数に変換する	int(s, 8)
黄色色のヒストグラムを描画する	plt.hist(データ列, color='yellow')
データ列を箱ひげ図で可視化する	plt.boxplot(データ列)
nがn2以下、または、n3以上か調べる	n <= n2 or n >= n3
データフレームのカラムの欠損値を中央値に設定する	df[col].fillna(df[col].median())
既存の配列を元に全要素が初期値の配列	np.full_like(aArray, 初期値)
リストとリストについて散布図を描画して、マーカーを三角に設定する	plt.plot(xdata, ydata, marker='^')
データフレームをグループ化し、それぞれの列に対し最大値を算出する	df.groupby(column)[column2].max()
グラフのサイズを設定する	plt.figure(figsize=(width, height))
ミディアムシアグリーン色のヒストグラムを描画する	plt.hist(データ列, color='mediumseagreen')
データフレームを複数の列によってによって降順にソートする	df.sort_values(by=column, ascending=False)
データフレームの各グループ毎の標準偏差	df.groupby(column).std()
＜オプション＞色をブラックに設定する	color = 'black'
配列の内積	np.dot(aArray, aArray2)
リストをy軸、イテラブルを横軸として大きさnの散布図を描画する	plt.scatter(xdata, ydata, s=n)
配列をn個にビン分割して、namesのラベルをつける	pd.cut(aArray, n, labels=names)
データフレームの列名を列から文字列に付け直す	df.rename(columns={column: name})
折れ線グラフを描画して、その色を紺碧に変更する	plt.plot(データ列, データ列2, color='azure')
リストとリストで明るいグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
CSVファイルタブ区切りのファイルをn番目のカラムをインデックスとして読み込む	pd.read_csv(filename, index_col=n)
現在が水曜日か調べる	datetime.datetime.today().weekday() == 2
ケンドール相関係数でデータフレームのリスト列の相関行列	df[aList].corr(method='kendall')
リストとイテラブルについて散布図を描き、、マーカーの色を色差別ないに指定する	plt.plot(xdata, ydata, c='colorblind')
データフレームのリスト列の中にある文字列の合計をカウントする	df[aList].isin([value]).sum()
文字列をコロンで分割して、文字列リストに変換する	s.split(':')
破線グラフの色を淡いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
文字列を複数行対応として正規表現で分ける	re.split(pattern, s, flags=re.MULTILINE)
ヒストグラムを描画して、その色をフクシアに変更する	plt.hist(データ列, color='fuchsia')
リストとリストについての散布図をパステル調の色で描画する	plt.plot(xdata, ydata, c='pastel')
値を赤色でプリントできる文字列に変換する	f'\033[31m{value}\033[0m'
散布図に淡い色のマーカーを使う	plt.plot(xdata, ydata, c='muted')
フクシアにヒストグラムの色をセットする	plt.hist(データ列, color='fuchsia')
データフレームのリストカラムの欠損値を中央値に設定する	df[aList].fillna(df[aList].median())
データフレームのリストカラムを丸める	df[aList].round()
第二コマンド引数	sys.argv[1]
標準出力をフラッシュする	sys.stdout.flush()
データフレームの列が文字列で始まらない行を取り出す	df[not df[column].str.startswith(s)]
データフレームのヒートマップを描画する	sns.heatmap(df.corr())
データ列をインポートする	import pandas as pd
データ列を折れ線グラフに描画してマーカーを星印にする	plt.plot(データ列, データ列2, marker='*')
辞書にマッピングの項目を更新する	aDict.update(aDict2)
データフレームのカラムの欠損値を最頻値で補う	df[col].fillna(df[col].mode().iloc[0])
組をナンバリングする	enumerate(aTuple)
リストと配列についての散布図に黒いバツマーカーを描画する	plt.plot(xdata, ydata, marker='x', c='k')
＜オプション＞グラフの色を青緑に設定する	color = 'turquoise'
未初期化の配列	np.empty(要素数, dtype=np.int)
大バツマーカーを散布図に使う	plt.plot(xdata, ydata, marker='X')
標準エラーを使う	sys.stderr
＜オプション＞グラフの色をフクシアに設定する	color = 'fuchsia'
線グラフの色をシアンに変更する	plt.plot(データ列, データ列2, color='cyan')
リスト内の要素が少なくともひとつ真か調べる	any(aList)
データフレームのそれぞれのグループごとの最小値を求める	df.groupby(column).min()
ヒストグラムを描画して、その色をカーキに設定する	plt.hist(データ列, color='khaki')
ヒストグラムの色をダークスレートブルーに設定する	plt.hist(データ列, color='darkslateblue')
配列をビン数nとしてビン分割して、namesのラベルをつける	pd.cut(aArray, n, labels=names)
小数点数はNaNかどうか	math.isnan(x)
データフレームの未入力値を直後の値で置換する	df.fillna(method='bfill')
リストの最初の文字列を探す	aList.index(element)
タプルをnからナンバリングする	enumerate(aTuple, start=n)
ヒストグラムを描画して、その色をシアンに設定する	plt.hist(データ列, color='cyan')
ライム色のヒストグラムを描画する	plt.hist(データ列, color='lime')
ファイルのファイルサイズ	os.path.get_size(filepath)
文字列の先頭でパターンにマッチするか見る	re.match(pattern, s)
２次元リストの転置行列	[list(x) for x in list(zip(*aList))]
タプルを引数として展開して表示する	print(*aTuple, sep=',')
ドジャーブルー色のヒストグラムを描画する	plt.hist(データ列, color='dodgerblue')
ひとつ飛ばしでリストを得る	aList[::2]
ポスターにグラフの目的を変更する	sns.set(context='poster')
折れ線グラフを描画してその色をカーキに指定する	plt.plot(データ列, データ列2, color='khaki')
文字列中に非空白が含まれるか確認する	any(not c.isspace() for c in s)
両端キュー中の値の位置	deq.index(element)
グローバル変数の一覧	globals()
黒い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='k')
＜オプション＞グリーンイエローにグラフの色を変更する	color = 'greenyellow'
散布図に赤色のポイントマーカーを用いる	plt.plot(xdata, ydata, marker='.', c='r')
データフレームの列の未入力値を平均値で埋める	df[col].fillna(df[col].mean())
イテラブルとリストについて色差別ない色の折れ線グラフを描画して線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
組合せ	math.comb(n, k)
オブジェクトからフィールドを削除する	delattr(obj, プロパティ名)
データフレームをJSONLファイルに保存する	df.to_excel(filename)
ヒストグラムの色をミディアムスレートブルーにセットする	plt.hist(データ列, color='mediumslateblue')
書き込み用にファイルパスをオープンする]	open(filepath, mode='w')
ヒストグラムを描画して、その色を黄色にする	plt.hist(データ列, color='yellow')
タプルの合計値を算出する	sum(aTuple)
＜オプション＞グラフの色をローングリーンにセットする	color = 'lawngreen'
nが1もしくは2、もしくは3に等しい	n == 1 or n == 2 or n == 3
'A'列と'B'列によってデータフレームをソートする	df.sort_values(by=['A', 'B'])
カラーコードのダイアモンドマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='D', c=rgb)
文字列が文字列リストに含まれるか調べる	s in aStringList
リストをリストを境界値としてビン分割する	pd.cut(aList, aList)
オプションで、標準エラーを出力にする	file = sys.stderr
色差別ないグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
リストを境界値として配列をビン分割する	pd.cut(aArray, aList)
本日を文字列でフォーマットする	"datetime.datetime.today().strftime(""%d/%m/%y"")"
二つの文字列が等しくないか	s != s2
nが何桁か	len(str(n))
リストと数列について明るいグラフを描いて、色を黒くする	plt.plot(xdata, ydata, linestyle='bright', color='k')
ヒストグラムを描画して、その色をミディアムターコイズに設定する	plt.hist(データ列, color='mediumturquoise')
データ列の中にがある	ds.isin([value])
タプルの全順列	itertools.permutations(iterable)
折れ線グラフを描画して、その色を黄緑に設定する	plt.plot(データ列, データ列2, color='chartreuse')
リストを緑色にする	f'\033[32m{value}\033[0m'
リストとリストについて破線グラフをプロットして、その色を明るいに設定する	plt.plot(xdata, ydata, linestyle='dash', color='bright')
データフレームの中で、列と列に重複があるか見る	df.duplicated(subset=[column, column2])
折れ線グラフに青い丸印を描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='b')
オリベドラブ色のヒストグラムを描画する	plt.hist(データ列, color='olivedrab')
＜オプション＞ライトスレイグレーにグラフの色を指定する	color = 'lightslategray'
本日の月	datetime.datetime.today().month
数式の簡略化を行う	sympy.sympify(e)
カラーコードの丸マーカーをデータ列と数列についての散布図にプロットする	plt.plot(xdata, ydata, marker='o', c=rgb)
カラーバーを描画する	plt.colorbar()
折れ線グラフの左三角マーカーを緑色にする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='g')
辞書の全項目をクリアする	aDict.clear()
データ列を等量でn個にビン分割する	pd.qcut(ds, n)
実数を実数で割る	x / y
折れ線グラフの色をシスルに設定する	plt.plot(データ列, データ列2, color='thistle')
カウンタの最も頻出な項目	aCounter.most_common()[0]
＜オプション＞データ型を指定する	dtype = np.int16
配列を元に全要素が1の行列	np.ones_like(aArray)
プロットで使う色をpalleteNameで指定する	sns.set(pallete=palleteName)
折れ線グラフを描画して、その色をサドルブラウンに設定する	plt.plot(データ列, データ列2, color='saddlebrown')
データフレームが正規分布からどの程度、尖っているか見る	df.skew()
カウンタ同士で共通部分	aCounter & aCounter2
文字列を大文字・小文字を無視して正規表現で分割する	re.split(pattern, s, flags=re.IGNORECASE)
TSVファイルを読み込む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
ふたつの集合が集合と交わりを持たないか調べる	aSet.isdisjoint(aSet2)
線グラフを描画してその色をリネンに設定する	plt.plot(データ列, データ列2, color='linen')
リストとリストのカラーコードの色差別ないを描く	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
実数のハイパボリック・コサインの逆数	math.acosh(x)
nが2で割り切れないか調べる	n % 2 == 1
全要素を1で初期化された配列	np.ones(要素数, dtype=np.int)
文字列を区切りによって分割して、列挙する	s.split(sep)
線グラフの色を小麦色に設定する	plt.plot(データ列, データ列2, color='wheat')
リストとリストの明るいグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='bright', color='k')
オブジェクトはタプルクラスか調べる	isinstance(obj, tuple)
データフレームからカラムを１つ選択する	df[[column]]
日付時刻データが何秒か知る	aDatetime.second
散布図に濃い色のマーカーを使う	plt.plot(xdata, ydata, c='deep')
＜オプション＞ダークスレートブルーを使う	color = 'darkslateblue'
連立方程式の解を求める	sympy.solve([e, e2])
折れ線グラフに線幅nの三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
折れ線グラフの左三角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='<', markersize=n)
折れ線グラフを描画して色をサンディーブラウンに変更する	plt.plot(データ列, データ列2, color='sandybrown')
横棒グラフを描画して、幅をxに設定する	plt.barh(ラベル列, データ列, width=x)
パープルにヒストグラムの色を指定する	plt.hist(データ列, color='purple')
折れ線グラフの色をライトゴールドロディイエローに設定する	plt.plot(データ列, データ列2, color='lightgoldenrodyellow')
データフレームの列を削除する	df.drop(column, axis=1)
ヒストグラムの色をライトグリーンに指定する	plt.hist(データ列, color='lightseagreen')
散布図に黒い三角マーカーを使う	plt.plot(xdata, ydata, marker='^', c='k')
線グラフの色をコーラルに設定する	plt.plot(データ列, データ列2, color='coral')
イテラブルの組み合わせ	itertools.combinations(iterable, n)
＜オプション＞深紅色を使う	color = 'crimson'
実数の双曲線正接の逆数	math.atanh(x)
リストと配列の青い色差別ないを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
辞書をソートしてJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, sort_keys=True)
タイムスタンプデータはタイムスタンプデータと同時か調べる	aDatetime == aDatetime2
双方向キューが空か	len(deq) == 0
＜オプション＞ライトスレイグレー色を使用する	color = 'lightslategrey'
折れ線グラフの色をクリムゾンに設定する	plt.plot(データ列, データ列2, color='crimson')
＜オプション＞スラッシュを区切りで使う	sep = '/'
＜オプション＞ダークスラテグレー色を使う	color = 'darkslategray'
データ列を折れ線グラフに描画して、マーカーを丸印にする	plt.plot(データ列, データ列2, marker='o')
リストとイテラブルの色差別ないグラフを描画して、その色を黒色に設定する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
＜オプション＞色をピーチパフに変更する	color = 'peachpuff'
データフレームを列によって小さい順にソートし、、更新する	df.sort_values(by=column, ascending=True, inplace=True)
小数点数の指数を求める	math.frexp(x)[1]
散布図に明るい色のマーカーを使う	plt.plot(xdata, ydata, c='bright')
カラーコードの星マーカーを散布図に用いる	plt.plot(xdata, ydata, marker='*', c=rgb)
カラムの欠損値をモードに設定する	ds.fillna(ds.mode().iloc[0])
データフレームの列がxの行を抽出する	df[df[column] == x]
カラーバーを設定する	plt.colorbar()
オプションで、標準エラーに出力する	file = sys.stderr
赤い星マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='*', c='r')
単位行列	np.eye(行数, 列数)
＜オプション＞グラフの色をディムグレーに設定する	color = 'dimgray'
本日が火曜日かどうか判定する	datetime.datetime.today().weekday() == 1
赤い星マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='*', c='r')
リストとリストの淡いグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='muted', color='k')
ヒストグラムの色を赤くする	plt.hist(データ列, color='r')
グラフの描画で色差別ないカラーパレットを用いる	sns.set(pallete='colorblind')
文字列が全て英数字かどうかテストする	s.isalnum()
折れ線グラフを描画して、その色をライトサーモンに変更する	plt.plot(データ列, データ列2, color='lightsalmon')
カラムの値が欠損値かどうか	ds.isna()
スレートブルー色のヒストグラムを描画する	plt.hist(データ列, color='slateblue')
折れ線グラフのスタイルを点線にする	plt.plot(データ列, データ列2, linestyle='dotted')
折れ線グラフを描画して、その色をサンディーブラウンに設定する	plt.plot(データ列, データ列2, color='sandybrown')
折れ線グラフのバツマーカーの線幅をnに指定する	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
リストとリストの散布図を描画し、、右三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='>', c=rgb)
グラフで使うフォントを日本語表示に設定する	sns.set(font='IPAexGothic')
折れ線グラフを描画して、色をオレンジに設定する	plt.plot(データ列, データ列2, color='orange')
折れ線グラフの三角マーカーを青くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='b')
ファイルをEUCで書き込み用にオープンする]	open(filepath, mode='w', encoding='euc_jp')
ファイルをバイナリモードとしてオープンする]	open(filepath, mode='rb')
日付時刻データのタイムゾーン	aDatetime.timetz()
日付時刻データををn分後に進める	aDatetime + datetime.timedelta(minutes=n)
データフレームのカラムを日付データに変換しデータフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(df[col]))
nがn2と等しいか調べる	n == n2
オブジェクトはバイト列型か	isinstance(obj, bytes)
データフレームの中の列をn個にビン分割して、namesのラベルをつける	pd.cut(df[col], n, labels=names)
year年month月day日hour時minute分のタイムスタンプ	datetime.datetime(year=year, month=month, day=day, hour=hour, minute=minute)
rangeの無限バージョン	itertools.count(start=n, step=step)
ファイルをバイナリ書き込みモードを用いてオープンする]	open(filepath, mode='wb')
ヒストグラムを描画して、その色をダークグレーに変更する	plt.hist(データ列, color='darkgray')
リストとリストについての散布図に星マーカーを描画する	plt.plot(xdata, ydata, marker='*')
度数分布図を描画し合計を1にする	plt.hist(データ列, density=True)
データフレームの中の列と列に重複があれば、マスクする	df.duplicated(subset=[column, column2])
文字列タブ区切りのファイルからn番目の列をインデックスとしてCSVファイルを読み込む	pd.read_csv(filename, index_col=n)
文字列を走査し、正規表現に複数行対応としてマッチするか調べる	re.search(pattern, s, flags=re.MULTILINE)
ナバホホワイト色の線グラフを描画する	plt.plot(データ列, データ列2, color='navajowhite')
標準入力から1行分読み込んで改行を取り除く	sys.stdin.readline().rstrip()
値を両端キューの末尾から取り除く	deq.pop()
文字列は十進数字か調べる	s.isdecimal()
データ列が何日か見る	ds.dt.day
表データを'A'列によって小さい順にソートする	df.sort_values(by='A', ascending=True)
＜オプション＞アクア色を使う	color = 'aqua'
＜オプション＞色をグレーに設定する	color = 'gray'
淡い色のマーカーで散布図を重なりを見やすくプロットする	plt.plot(xdata, ydata, c='muted', alpha=0.5)
折れ線グラフの色をパウダーブルーにセットする	plt.plot(データ列, データ列2, color='powderblue')
色差別ないグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
ロイヤルブルーにヒストグラムの色をセットする	plt.hist(データ列, color='royalblue')
データフレームの列の値が欠損値か調べる	df[col].isna()
データフレームのリスト列の欠損値を最大値で埋める	df[aList].fillna(df[aList].max())
＜オプション＞無視するフッタをnに設定する	skipfooter = n
暗いグラフの色を青にする	plt.plot(xdata, ydata, linestyle='dark', color='b')
Pythonパスにディレクトリを追加する	sys.path.append(dir)
ヒストグラムの色をミディアムアクアマリンに設定する	plt.hist(データ列, color='mediumaquamarine')
カラーコードの三角マーカーを配列とリストの散布図に描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
正規表現patternで一度にreplにデータフレームの値を置き換える	df.replace(pattern, repl, regex=True)
xの小数点以下'1'桁までの文字列に変換する	':.1f'.format(x)
濃いシアンにヒストグラムの色を設定する	plt.hist(データ列, color='darkcyan')
リストとリストの散布図に黒い丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c='k')
濃い色のマーカーを使って散布図を重なりを見やすくプロットする	plt.plot(xdata, ydata, c='deep', alpha=0.5)
明るいの色を黒色に設定する	plt.plot(xdata, ydata, linestyle='bright', color='k')
リストとリストについての散布図に黒色の下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v', c='k')
オブジェクトはリストクラスのインスタンス	isinstance(obj, list)
データフレームの中に含まれる文字列の合計を数える	df.isin([value]).sum()
折れ線グラフに線幅nのダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
折れ線グラフを描画して、色を白くする	plt.plot(データ列, データ列2, color='w')
文字列をISO書式で日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
日付時刻データにn秒分、加算する	aDatetime + datetime.timedelta(seconds=n)
データフレームの列のユニークな値の個数	df[col].nunique()
折れ線グラフの色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgray')
JSONファイルのfをデータに変換する	json.load(fin)
データフレームを表示するとき、小数点以下n桁まで表示可能なようにする	pd.set_option('precision', n)
データフレームのstart行目からend行目まで抽出する	df[start:end]
グラフの見栄えを綺麗にする	import seaborn as sns
＜オプション＞グラフの色をミディアムシアグリーンにする	color = 'mediumseagreen'
配列とリストについて散布図を描画して、マーカーを丸に設定する	plt.plot(xdata, ydata, marker='o')
配列のユニークな要素とその個数	u, counts = np.unique(aArray, return_counts=True)
データフレームから型の列だけ選択する	df.select_dtypes(ty)
リストとリストについて散布図を描画して、三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='^', c=rgb)
数式の変数についてのn階微分を求める	sympy.diff(e, z, n)
文字列が全て空白かどうか	s.isspace()
＜オプション＞右三角印を使用する	marker = '>'
最大値・最小値の範囲で一様な乱数	random.uniform(最小値, 最大値)
標準入力から1行分改行なしで読む	sys.stdin.readline().rstrip()
グラフ中の(x,y)の場所に補足を加える	plt.legend(loc=(x, y))
折れ線グラフの丸マーカーを緑色にする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='g')
折れ線グラフのアルファをalphaに指定する	plt.plot(xdata, ydata, alpha=alpha)
列'A'と列'B'をキーとして2つのデータフレームを左結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='left')
データフレームを表示するとき、表示される列数の最大値をnに変更する	pd.set_option('display.max_columns', n)
ファイルをBOM付きでオープンする]	open(filepath, encoding='utf_8_sig')
既存の配列を元に全要素が1の配列	np.ones_like(aArray)
グラフの中の日本語フォントを有効にする	sns.set(font='IPAexGothic')
折れ線グラフを描画して、その色をピーチパフにセットする	plt.plot(データ列, データ列2, color='peachpuff')
nにn2をかける	n * n2
predicateFuncが真となるシーケンスの要素	itertools.takewhile(predicateFunc, iterable)
オブジェクトのクラス	type(obj)
ヒストグラムを描画して、その色をゴールドに設定する	plt.hist(データ列, color='gold')
カラーバーを横向きで設定する	plt.colorbar(orientation='horizontal')
ヒストグラムを描画して、その色をミントクリームに設定する	plt.hist(データ列, color='mintcream')
配列と配列についての散布図に黒色の大バツマーカーを描く	plt.plot(xdata, ydata, marker='X', c='k')
カンマで文字列を区切って、文字列リストに変換する	s.split(',')
＜オプション＞グラフの色をライトゴールドロディイエローに変更する	color = 'lightgoldenrodyellow'
ディープスカイブルー色のヒストグラムを描画する	plt.hist(データ列, color='deepskyblue')
リストとリストで暗いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
散布図に黒いクロスマーカーを用いる	plt.plot(xdata, ydata, marker='x', c='k')
Pandasで、データ列をdatetime64型に変換しインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(ds))
データフレームの列の各値は何回出現するか確認する	df[col].value_counts()
データフレームの列が文字列で終わらない行を抽出する	df[not df[column].str.endswith(s)]
リストを青色にする	f'\033[34m{value}\033[0m'
四分位数ごとに配列をビン分割する	pd.qcut(aArray, 4)
全ての空白文字	string.whitespace
日付データと日付データの時間差を秒数で求める	(aDate - aDate2).total_seconds()//60
棒グラフの色をカラーコードに設定する	plt.bar(ラベル列, データ列, color=rgb)
棒グラフをプロットして、グラフ幅をxに設定する	plt.bar(ラベル列, データ列, width=x)
文字列全体がパターンにASCII限定としてマッチするか見る	re.fullmatch(pattern, s, flags=re.ASCI)
カウンタを少ない方からリストとして得る	aCounter.most_common()[::-1]
＜オプション＞グラフの色をブルーバイオレットに設定する	color = 'blueviolet'
折れ線グラフに描画して、印を星印にする	plt.plot(データ列, データ列2, marker='*')
折れ線グラフの色をレベッカパープルに設定する	plt.plot(データ列, データ列2, color='rebeccapurple')
折れ線グラフのバツマーカーを赤くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='r')
＜オプション＞アンティークホワイトを使う	color = 'antiquewhite'
赤色の四角マーカーで散布図を描く	plt.plot(xdata, ydata, marker='s', c='r')
折れ線グラフの色をライトスレイグレーに変更する	plt.plot(データ列, データ列2, color='lightslategray')
データフレームを列の値によってグループ化する	df.groupby(column)
黒いバツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x', c='k')
折れ線グラフを描画してその色を赤に設定する	plt.plot(データ列, データ列2, color='red')
色差別ない色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データフレームの欠損値を前の行の値に設定する	df.fillna(method='ffill')
xの小数点以下'3'桁までの文字列に変換する	':.3f'.format(x)
２次元組をflattenする	sum(aTuple)
列'A'と列'B'をキーにして2つのデータフレームを結合する	pd.merge(df, df2, left_on='A', right_on='B')
紺碧にヒストグラムの色を設定する	plt.hist(データ列, color='azure')
折れ線グラフに線幅nの大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markeredgewidth=n)
データフレームの平均を計算する	df.mean()
アルファベットを全部使う	string.ascii_letters
＜オプション＞パレットトルコイズ色を使う	color = 'paleturquoise'
データフレームから重複する行を残さず消す	df.drop_duplicates(keep=False)
データフレームの最頻値を求める	df.mode()
散布図に赤い右三角マーカーを用いる	plt.plot(xdata, ydata, marker='>', c='r')
nが5の倍数か確認する	n % 5 == 0
二つの列の値ごとにデータフレームを集約して列挙する	[(name, group) for name, group in df.groupby(['A', 'B'])]
コマンド引数を列挙する	sys.argv[1:]
nのn2乗	n ** n2
＜オプション＞グラフの種類を点線に設定する	linestyle = 'dotted'
散布図をカラーコードの丸マーカーで描画する	plt.plot(xdata, ydata, marker='o', c=rgb)
ミディアムブルーにヒストグラムの色を設定する	plt.hist(データ列, color='mediumblue')
＜オプション＞スチールブルー色を用いる	color = 'steelblue'
赤い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
型が名前付きタプルか調べる	issubclass(C, tuple)
辞書をインデント幅nのJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, indent=n)
乱数シードをnで初期化する	random.seed(n)
＜オプション＞パープルを使用する	color = 'purple'
赤色の星マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='*', c='r')
ファイルからファイル名を使う	os.path.basename(filepath)
列と列から重複を取り除く	set(ds.unique().tolist()+ds2.unique().tolist())
ライトゴールドロディイエロー色のヒストグラムを描画する	plt.hist(データ列, color='lightgoldenrodyellow')
ヒストグラムを描画して、その色をライトコーラルに設定する	plt.hist(データ列, color='lightcoral')
文字列の中の大文字・小文字を無視してパターンによる全てのマッチを求める	re.findall(pattern, s, flags=re.IGNORECASE)
タプルをn回、連結する	aTuple * n
ボックスチャートを二つ並べる	plt.boxplot([データ列, データ列2])
文字列が全て大文字か調べる	s.isupper()
配列とリストの黒いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='k')
暗いグラフの色を黒色に変更する	plt.plot(xdata, ydata, linestyle='dark', color='k')
データフレームを2つの列によってソートして、更新する	df.sort_values(by=['A', 'B'], inplace=True)
リストとリストのカラーコードの濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
＜オプション＞クリムゾンにグラフの色を指定する	color = 'crimson'
パープル色の線グラフを描画する	plt.plot(データ列, データ列2, color='purple')
データフレームを複数の列によってソートして、更新する	df.sort_values(by=column, inplace=True)
JSONLファイルにTSVファイルでデータフレームを保存する	df.to_csv(filename, sep='\t')
ヒストグラムの色をオレンジレッドに変更する	plt.hist(データ列, color='orangered')
データフレームの下位25%	df.quantile(0.75)
カウンタを高頻出方からリストとして得る	aCounter.most_common()
今日は何日か知る	datetime.datetime.today().day
データフレームのリストカラムの下位25%	df[aList].quantile(0.75)
データフレームを複数の列によってソートして、NaNを先頭にする	df.sort_values(by=column, na_position='first')
折れ線グラフを描画して、その色をスチールブルーに設定する	plt.plot(データ列, データ列2, color='steelblue')
8進文字列をバイト列に変換する	int(s, 8).to_bytes(length=bytesize, byteorder='big')
横棒を描画する	plt.barh(ラベル列, データ列)
折れ線グラフの▽マーカーを黄色くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='y')
year年month月の日付	datetime.date(year=year, month=month, day=1)
データ列を折れ線グラフに描画して、マーカーを右三角印にする	plt.plot(データ列, データ列2, marker='>')
配列とデータ列について散布図を描画して文字列という凡例用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
ヒートマップを用いてデータフレームの相関行列を描画する	sns.heatmap(df.corr())
全要素を０で初期化された符号なし８ビット整数型の行列	np.zeros(行数, 列数, dtype=np.uint8)
折れ線グラフの色をインディゴに設定する	plt.plot(データ列, データ列2, color='indigo')
二つの整数最小公倍数	math.lcm(n, n2)
＜オプション＞ミディアムシアグリーン色を使う	color = 'mediumseagreen'
イテラブルからn個、サンプリングする	random.sample(iterable, k=n)
線グラフを描画して、その色をミディアムアクアマリンに変更する	plt.plot(データ列, データ列2, color='mediumaquamarine')
文字列を末尾から部分文字列で区切る	s.rsplit(sub)
マゼンタ色の線グラフを描画する	plt.plot(データ列, データ列2, color='magenta')
ヒストグラムの色をライトスレイグレーに設定する	plt.hist(データ列, color='lightslategray')
折れ線グラフを描画して、色をコーンフラワーブルーに設定する	plt.plot(データ列, データ列2, color='cornflowerblue')
データフレームの列がxでない行を消す	df[df[column] == x]
線幅nのクロスマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
辞書のキーとその項目をペアとして取り出す	aDict.items()
Pandasで、データフレームのcollをフォーマットfmtを使って日付データに変換する	pd.to_datetime(df[col], format=fmt)
折れ線グラフを描画して、その色をベージュに指定する	plt.plot(データ列, データ列2, color='beige')
折れ線グラフの色をゴーストホワイトに設定する	plt.plot(データ列, データ列2, color='ghostwhite')
行列の行	aArray[行番号]
値を下線付きで表示する	print(f'\033[4m{value}\033[0m')
イテラブルを双方向キューに変換する	collections.deque(iterable)
折れ線グラフを描画して色をグレーに設定する	plt.plot(データ列, データ列2, color='gray')
黒色で文字列をプリントする	print(f'\033[30m{value}\033[0m')
ヒストグラムを描画して色をサドルブラウンに設定する	plt.hist(データ列, color='saddlebrown')
ヒストグラムを描画してその色をサドルブラウンに設定する	plt.hist(データ列, color='saddlebrown')
リストの末尾からn番目以前の部分を取り出す	aList[:-n]
＜オプション＞スレートブルーを使う	color = 'slateblue'
リストをヒストグラムにする	plt.hist(aList)
折れ線グラフに三角印を使う	plt.plot(データ列, データ列2, marker='^')
＜オプション＞グラフの色をゲインズボロに設定する	color = 'gainsboro'
データフレームの未入力値を最頻値で補う	df.fillna(df.mode().iloc[0])
データフレームのカラムの欠損値を平均値で埋める	df[col].fillna(df[col].mean())
折れ線グラフのダイアモンドマーカーを緑色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='g')
折れ線グラフの色をオレンジレッドに設定する	plt.plot(データ列, データ列2, color='orangered')
整数の複素数	complex(x)
リストと配列の散布図にカラーコードの▼マーカーを描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
折れ線グラフに黒い四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='k')
文字列中のタブ文字をn個の空白に置き換える	s.expandtabs(tabsize=n)
数式を微分する	sympy.diff(e)
＜オプション＞追加モードに設定する	mode = 'a'
nの桁数	len(str(n))
＜オプション＞グラフの色をピーチパフに設定する	color = 'peachpuff'
データ列とリストについての散布図を暗い色でプロットする	plt.plot(xdata, ydata, c='dark')
データフレームの中の列を等間隔でn個にビン分割する	pd.cut(df[col], n)
データフレームのリストカラムの中にある文字列と文字列の合計を数える	df[aList].isin([value, value2]).sum()
変数名をキーとして、マッピングを作る	dict(name=element)
データフレームを２つの列によって小さい順に破壊的に並べる	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
データフレームのn行まで抽出する	df[:n]
各列毎にデータフレームをグループ化し、、列の分散を計算する	df.groupby(column)[column2].var()
文字列がリストの要素でないかどうか調べる	element not in aList
ヒストグラムの色をマルーンに設定する	plt.hist(データ列, color='maroon')
ヒストグラムを描画してその色をインディアンレッドに設定する	plt.hist(データ列, color='indianred')
カウンタの項目を一つ増やす	aCounter[element] += 1
＜オプション＞複数行に対応する	flag = re.MULTILINE
データ列の中に文字列と文字列がある	ds.isin([value, value2])
折れ線グラフのバツマーカーの大きさをnに変更する	plt.plot(データ列, データ列2, marker='x', markersize=n)
文字列をn回だけ置き換える	s.replace(sub, newsub, n)
折れ線グラフを破線で描画する	plt.plot(データ列, データ列2, linestyle='dashed')
文字列TSVファイルからCSVファイルをn番目のカラムをインデックスとして読み込む	pd.read_csv(filename, index_col=n)
文字列の大文字と小文字を逆にする	s.swapcase()
実数をn乗する	x ** n
実数の逆余弦	math.acos(x)
リストとリストについての散布図を濃い色で描画する	plt.plot(xdata, ydata, c='deep')
本日が日曜日	datetime.datetime.today().weekday() == 6
太字で文字列をプリントする	print(f'\033[1m{value}\033[0m')
文字列の先頭で正規表現にASCII限定としてマッチするか見る	re.match(pattern, s, flags=re.ASCI)
データフレームから重複する行を破壊的に削除する	df.drop_duplicates(inplace=True)
紺碧色のヒストグラムを描画する	plt.hist(データ列, color='azure')
カラーコードのクロスマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x', c=rgb)
列とイテラブルのデカルト積	itertools.product(iterable, iterable2)
ゲインズボロ色のヒストグラムを描画する	plt.hist(データ列, color='gainsboro')
行列式を求める	np.linalg.det(aArray)
日付時刻データが日付時刻データより前か	aDatetime < aDatetime2
集合から全要素を消す	aSet.clear()
折れ線グラフのバツ印を赤くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='r')
リストとリストについて散布図を描画して、下三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='v', c=rgb)
パスのセパレータ記号を使う	os.sep
散布図をパステル調の色のマーカーで描画する	plt.plot(xdata, ydata, c='pastel')
データフレームを関数でグループ化し記述統計量を求める	df.groupby(関数).describe()
＜オプション＞スラグレーに色を設定する	color = 'slategrey'
折れ線グラフを描画してその色をイエローグリーンに変更する	plt.plot(データ列, データ列2, color='yellowgreen')
プログラムの実行を正しく終了する	sys.exit(0)
0からNまでの配列	np.arange(N)
折れ線グラフの星マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='*', markeredgewidth=n)
ヒストグラムの線のスタイルを一点鎖線に設定する	plt.hist(データ列, linestyle='dashbot')
折れ線グラフを描画して、その色をラベンダーブラッシュに設定する	plt.plot(データ列, データ列2, color='lavenderblush')
配列とリストで濃いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
ファイルをバイナリモードとしてオープンして]、fとする	f = open(filepath, mode='rb')
リストを小さい順にソートする	sorted(aList, reverse=False)
折れ線グラフのマーカーをバツ印にする	plt.plot(データ列, データ列2, marker='x')
縦棒グラフを描画し、、中央寄せする	plt.bar(ラベル列, データ列, align='center')
双方向キューのn番目に要素を途中追加する	deq.insert(n, element)
文字列の右側から空白を取り除く	s.rstrip()
リストと配列の散布図に赤い丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c='r')
折れ線グラフを描画して、その色をペルーに設定する	plt.plot(データ列, データ列2, color='peru')
データフレームのリストカラムの第一四分位数	df[aList].quantile(0.25)
シーケンスのそれぞれを関数でフィルタする	map(func, iterable)
カラムの基本統計量	ds.describe()
全要素が1の行列	np.ones(行数, 列数, dtype=np.int)
自然数の最大公約数	math.gcd(n, n2)
エクセルファイルをエクセルファイルファイルから読み込む	pd.read_excel(filename)
＜オプション＞グラフの色をゴールドに変更する	color = 'gold'
ミディアムアクアマリン色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumaquamarine')
タイムスタンプデータの年数を見る	aDatetime.year
折れ線グラフを描画して、その色をパレットトルコイズに設定する	plt.plot(データ列, データ列2, color='paleturquoise')
リストをビン分割する	pd.cut(aList, aList)
データフレームのリスト列の中に文字列と日付データがいくつ含まれるか求める	df[aList].isin([value, value2]).sum()
折れ線グラフに線幅nのポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markeredgewidth=n)
データ列とリストについてパステル調のグラフを描いて、その色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
折れ線グラフのクロスマーカーを黄色くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='y')
散布図に赤色の菱形マーカーを使う	plt.plot(xdata, ydata, marker='D', c='r')
折れ線グラフの色をチョコレートに指定する	plt.plot(データ列, データ列2, color='chocolate')
散布図に四角マーカーを使う	plt.plot(xdata, ydata, marker='s')
文字列全体をケースを無視して正規表現にマッチさせる	re.fullmatch(pattern, s, flags=re.IGNORECASE)
集合から別の集合との共通要素を全て取り除く	aSet.symmetric_difference_update(aSet2)
データフレームのカラムの中のNaNの合計を数える	df[col].isna().sum()
レベッカパープル色の線グラフを描画する	plt.plot(データ列, データ列2, color='rebeccapurple')
グラフにy=0の一点鎖線を付ける	plt.axhline(y=0, linestyle='dashbot')
折れ線グラフの色を青に設定する	plt.plot(データ列, データ列2, color='blue')
淡いグラフをリストとリストでプロットし、、線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
折れ線グラフを描画してその色を淡いピンク色に設定する	plt.plot(データ列, データ列2, color='lightpink')
ミディアムオーキッドにヒストグラムの色を設定する	plt.hist(データ列, color='mediumorchid')
黒い丸印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='k')
データフレームの行を条件でフィルタするには	df[(df[column] == x) & (df[column2] == x2)]
明るいグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='bright', color='k')
＜オプション＞ダークシアグリーン色を使う	color = 'darkseagreen'
データ列が何時か見る	ds.dt.hour
文字列の接尾辞から部分文字列を消す	s.removesuffix(sub)
折れ線グラフの色をスノーに変更する	plt.plot(データ列, データ列2, color='snow')
＜オプション＞グラフの色をアイボリーに設定する	color = 'ivory'
ダークカーキ色のヒストグラムを描画する	plt.hist(データ列, color='darkkhaki')
リストをパステル調の色の柱状図でプロットする	plt.hist(xdata, color='pastel')
文字列をシアンでプリントする	print(f'\033[36m{value}\033[0m')
データフレームのリスト列の分散	df[aList].var()
データフレームの欠損値をxに指定する	df.fillna(x)
データ列が何分か見る	ds.dt.minute
折れ線グラフの色をグレーに設定する	plt.plot(データ列, データ列2, color='grey')
二つの変数を順にプリントする	print(value, value2)
データフレームを列によってソートして、行を振り直す	df.sort_values(columns).reset_index(drop=True)
データフレームを列の値ごとにグループ化して、それぞれのグループごとの個数を求める	df.groupby(column).count()
現在の秒数を求める	datetime.date.today().second
＜オプション＞オーキッド色を使う	color = 'orchid'
データフレームを列名リストによってソートする	df.sort_values(by=column)
データフレームの指定された列をリストとして抽出する	df[column].values.tolist()
ミディアムパープル色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumpurple')
整数nの二進数表現	bin(n)
データフレームのカラムのタイムゾーンを文字列に設定する	df[col].tz_convert(s)
＜オプション＞グラフの色をライトスレイグレーに設定する	color = 'lightslategrey'
折れ線グラフの色をライトイエローに設定する	plt.plot(データ列, データ列2, color='lightyellow')
文字列を改行で分割し、文字列リストに変換する	s.splitlines()
データ列の平均値を計算する	ds.mean()
ヒストグラムの色をミディアムバイオレットレッドに指定する	plt.hist(データ列, color='mediumvioletred')
文字列内にアスキー文字が含まれるか	any(c.isascii() for c in s)
日付データが日付データより前かどうか調べる	aDate < aDate2
リストと配列の折れ線グラフを描画し、色を文字列に設定する	plt.plot(xdata, ydata, color=s)
＜オプション＞色をアンティークホワイトに設定する	color = 'antiquewhite'
数字を全部見る	string.digits
ヒストグラムを描画して、色をアリスブルーに設定する	plt.hist(データ列, color='aliceblue')
トマト色のヒストグラムを描画する	plt.hist(データ列, color='tomato')
データフレームの行と列を入れ替える	df.T
数式の変数に数式を代入する	e.subs(z, e2)
句読点文字を全部使う	string.punctuation
折れ線グラフを描画して、その色をペールグリーンに設定する	plt.plot(データ列, データ列2, color='palegreen')
回数を制限して新しい文字列に文字列中の部分文字列を置き換える	s.replace(sub, newsub, n)
ヒストグラムを描画して、色をダークスラテグレーに設定する	plt.hist(データ列, color='darkslategray')
リストとデータ列の淡いグラフをプロットして、その色を黒にする	plt.plot(xdata, ydata, linestyle='muted', color='k')
ヒストグラムの色をサンディーブラウンに指定する	plt.hist(データ列, color='sandybrown')
データフレームのカラムの中にいくつ欠損値が含まれるか数える	df[col].isna().sum()
データフレームから型の列のみ取り出す	df.select_dtypes(ty)
＜オプション＞グラフの種類を破線に設定する	linestyle = 'dashed'
ヒストグラムの色をダークゴールデンロッドに変更する	plt.hist(データ列, color='darkgoldenrod')
カウンタ同士で積集合演算する	aCounter & aCounter2
＜オプション＞グラフの色を青緑に指定する	color = 'teal'
タプルのキーの値を得る	aDict[key]
整数nの十六進表現を見る	hex(n)
nから無限にカウントアップする	itertools.count(start=n)
折れ線グラフを描画してその色をシアンに変更する	plt.plot(データ列, データ列2, color='cyan')
ラベンダー色のヒストグラムを描画する	plt.hist(データ列, color='lavender')
データ列を百の位で丸めて、整数型にする	ds.round(-2).astype(int)
ヒストグラムを描画して、その色を青緑に設定する	plt.hist(データ列, color='turquoise')
淡い色の折れ線グラフを描画し、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
データフレームのリスト列の欠損値を直後の値で埋める	df[aList].fillna(method='bfill')
データフレームで、列の重複を見る	df.duplicated(subset=column)
カラーコードの丸マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='o', c=rgb)
データフレームの標本標準偏差	df.std()
イエローグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='yellowgreen')
パステル調のグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
＜オプション＞グラフの色をレモンシフォンに変更する	color = 'lemonchiffon'
折れ線グラフの色をライトブルーに設定する	plt.plot(データ列, データ列2, color='lightblue')
等間隔でn個にデータフレームの中の列をビン分割する	pd.cut(df[col], n)
データフレームのどの値が頻出か調べる	df.mode()
＜オプション＞読み込まないフッタをnに設定する	skipfooter = n
ヒストグラムの色をダークスラテグレーに設定する	plt.hist(データ列, color='darkslategray')
nの各桁の総和	sum(map(int, str(n)))
データフレームを各列毎に集計して列の標準偏差を算出する	df.groupby(column)[column2].std()
文字列を太字にする	f'\033[1m{value}\033[0m'
線グラフの色をフローラルホワイトに変更する	plt.plot(データ列, データ列2, color='floralwhite')
リストとリストについての散布図にカラーコードの星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c=rgb)
ファイルをBOM付きで追加できるように開く]	open(filepath, mode='a', encoding='utf_8_sig')
小麦色色のヒストグラムを描画する	plt.hist(データ列, color='wheat')
データフレームのリスト列の尖度	df[aList].skew()
赤いポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.', c='r')
データフレームのリスト列を四捨五入して整数型にする	df[aList].round().astype(int)
ヒストグラムの色を貝殻に設定する	plt.hist(データ列, color='seashell')
ヒストグラムを描画して、その色をシエナに設定する	plt.hist(データ列, color='sienna')
小数点以下をn桁に設定する	pd.set_option('precision', n)
＜オプション＞グラフの色をライトグレーに設定する	color = 'lightgrey'
データフレームのn行目を削除する	df.drop(n, axis=0)
折れ線グラフの色を紺に設定する	plt.plot(データ列, データ列2, color='darkblue')
リストとデータ列についての散布図を暗い色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='dark', alpha=0.5)
データフレームの第一四分位数	df.quantile(0.25)
読み込みできるようにファイルをオープンする]	open(filepath, mode='r')
リストを両端キューにする	collections.deque(iterable)
データフレームの中で、列と列の重複を削除する	df.drop_duplicates(subset=column)
＜オプション＞グラフの色をマゼンタに変更する	color = 'magenta'
文字列を文字コードエスケープでバイト列に変換する	s.encode(encoding='unicode_escape')
折れ線グラフを描画して色をミディアムオーキッドにセットする	plt.plot(データ列, データ列2, color='mediumorchid')
データ列とラベル列を指定して、積み上げ横棒グラフを描画する	"plt.barh(ラベル列, データ列, bottom=データ列2, color=""red"")"
方程式の解	sympy.solve(e)
二次元タプルをflattenする	sum(aTuple)
データ列とリストの折れ線を文字列の色で描く	plt.plot(xdata, ydata, color=s)
文字列を空白で区切って、整数のリストに変換する	map(int, s.split())
nまでの奇整数列	list(range(1, n, 2))
ヒストグラムを描画して、その色をミディアムオーキッドに設定する	plt.hist(データ列, color='mediumorchid')
データ列を使う	import pandas as pd
三つのデータフレームを横向きに合体させる	pd.concat([df, df2, df3], axis=1)
データフレームのカラムの標本標準偏差	df[col].std()
スラグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='slategray')
nからn2までのひとつ飛ばしの整数リスト	list(range(n, n2+1, 2))
グラフの描画を見やすくする	import seaborn as sns
文字列は組に含まれるか調べる	element in aTuple
折れ線グラフの下三角印を黄色くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='y')
カラムの最頻値	ds.mode()
既存のファイルを文字コードtextで追加できるようにオープンする]	open(filepath, mode='a', encoding=text)
八進数字を全て求める	string.octdigits
本日が木曜日	datetime.datetime.today().weekday() == 3
データ列とリストの破線を描画して、その色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
データフレームから列を三つ選択する	df[[column, column2, column3]]
パープル色のヒストグラムを描画する	plt.hist(データ列, color='purple')
折れ線グラフの四角マーカーを青くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='b')
EUCとしてファイルを開く]	open(filepath, encoding='euc_jp')
辞書を浅く複製する	aDict.copy()
プラム色のヒストグラムを描画する	plt.hist(データ列, color='plum')
折れ線グラフの右三角マーカーを青くする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='b')
データ列を濃い色の柱状図を使って描画する	plt.hist(xdata, color='deep')
プロットの描画で明るいカラーパレットを用いる	sns.set(pallete='bright')
行列の次元数を求める	aArray.ndim
データフレームを各列と列の組み合わせ毎にグループ化し、平均値を求める	df.groupby([column, column2], as_index=False).mean()
リストの長さを調べる	len(aList)
グラフをプロットする準備をする	from sympy import N
自然数個のものからk個取り出したときの並べ方の総数を求める	math.perm(n, k)
イテラブルから重複を取り除く	set(iterable)
文字列をプリントする	print(value)
黒い右三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='>', c='k')
データ列をstartからendの範囲の柱状グラフを用いて描画する	plt.hist(データ列, range=(start, end))
データ列の標本標準偏差	ds.std()
x,yの複素数を求める	complex(x, y)
ピアソン相関係数でデータフレームのリスト列の相関行列	df[aList].corr(method='pearson')
イテラブルとリストの散布図を描画して、ダイアモンドマーカーの色をカラーコードにセットする	plt.plot(xdata, ydata, marker='D', c=rgb)
オブジェクトをイテラブルに変換する	iter(obj)
データフレームから最後の列を除く	df[df.columns[:-1]]
文字列を最後の部分文字列で分けたときの後半の文字列を使う	s.rpartition(sub)[-1]
文字列の先頭から空白を取り除く	s.lstrip(' ')
配列の全要素の値を変更する	aArray[:, :] = 指定の値
グラフをいい感じに設定する	sns.set()
両端キュー中の要素の出現数を数える	deq.count(element)
プログラムの実行をエラーとして停止する	sys.exit(1)
配列の列ごとの平均値を求める	np.mean(aArray, axis=0)
スクリプトファイルの絶対パスを見る	os.path.abspath(__file__)
辞書をチェーンマップに変換する	collections.ChainMap(aDict)
＜オプション＞ミディアムバイオレットレッドを用いる	color = 'mediumvioletred'
名前からカラーマップを使う	"plt.get_cmap(""カラーマップ名"")"
ビン数をnに設定してヒストグラムを描画する	plt.hist(データ列, bins=n)
黒い三角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
文字列をマゼンタでプリントできる文字列に変換する	f'\033[35m{value}\033[0m'
実数の逆正弦	math.asin(x)
にx=0の実線を付ける	plt.axvline(x=0, linestyle='solid')
データフレームのそれぞれのグループの平均値	df.groupby(column).mean()
実数の双曲線正弦の逆数	math.asinh(x)
日付時刻データが火曜日か調べる	aDatetime.weekday() == 1
線グラフを描画して、色をコーンズシルクに設定する	plt.plot(データ列, データ列2, color='cornsilk')
データ列を折れ線グラフに描画して、マーカーを下三角印にする	plt.plot(データ列, データ列2, marker='v')
暗いグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='dark', color='r')
プログラムを適切に終了する	sys.exit(0)
文字列の片仮名を平仮名に変換する	''.join([chr(ord(ch) - 96) if ('ァ' <= ch <= 'ン') else ch for ch in s])
Pandasで、データフレームのcollのUNIX秒からdatetime64型に変換する	pd.to_datetime(df[col], unit='s', utc=True)
数列と配列についての散布図を大きさnで描く	plt.scatter(xdata, ydata, s=n)
＜オプション＞カーキにグラフの色を指定する	color = 'khaki'
ファイルをバイナリ書き込みモードでオープンする]	open(filepath, mode='wb')
＜オプション＞セパレータを改行にする	sep = '\n'
リストとリストで濃いグラフを描いて、線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
日付データと日付データの時間差	aDate - aDate2
濃いの色を黒色に設定する	plt.plot(xdata, ydata, linestyle='deep', color='k')
文字列でフォーマットして日付時刻データを文字列にする	"aDatetime.strftime(""%d/%m/%y"")"
黒色の淡いを描画する	plt.plot(xdata, ydata, linestyle='muted', color='k')
タプルの合計値	sum(aTuple)
アルファalphaの折れ線グラフを描画する	plt.plot(xdata, ydata, alpha=alpha)
ヒストグラムを二つ並べて描画する	plt.hist([データ列, データ列2], color=['b', 'r'])
ダークスレートブルーにヒストグラムの色を指定する	plt.hist(データ列, color='darkslateblue')
ディムグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='dimgrey')
リストをn回、連結する	aList * n
ヒストグラムを描画して、その色をディープスカイブルーに設定する	plt.hist(データ列, color='deepskyblue')
ピーチパフ色のヒストグラムを描画する	plt.hist(データ列, color='peachpuff')
文字列の先頭の空白を取り除く	s.lstrip()
データフレームの中にいくつ欠損値が含まれるかカウントする	df.isna().sum()
カウンタ同士で積集合	aCounter & aCounter2
文字列をバイト列に変換する	bytes(s)
オプションで、出力先をファイルに設定する	file = sys.open(filename, 'w')
オブジェクトの固有のID	id(obj)
nが2で割り切れるかどうか調べる	n % 2 == 0
データフレームをJSONLファイルに小数点以下3桁まで保存する	df.to_csv(filename, float_format='%.3f')
データフレームの列名を付け直す	df.rename(columns={column: name})
データフレームから重複した行を削除する	df.drop_duplicates()
＜オプション＞色をモカシンに設定する	color = 'moccasin'
nが奇数かどうか	n % 2 == 1
データ列を1000の位で丸めて、整数型にする	ds.round(-3).astype(int)
タンジェントの逆数を計算する	math.atan(x)
真	True
ゴーストホワイト色のヒストグラムを描画する	plt.hist(データ列, color='ghostwhite')
データフレームの指定された列だけ抽出する	df[[column]]
日付データにn時間分、加算する	aDate + datetime.timedelta(hours=n)
ヒストグラムを描画してその色をラベンダーに設定する	plt.hist(データ列, color='lavender')
文字列リストをsepを区切りとして結合する	sep.join(aStringList)
ヒストグラムを描画して、色をダークスレートブルーに設定する	plt.hist(データ列, color='darkslateblue')
文字列を最後の部分文字列で分割したときの前半の文字列を使う	s.rpartition(sub)[0]
赤い三角マーカーを配列とリストについての散布図に描く	plt.plot(xdata, ydata, marker='^', c='r')
ディレクトリをfilepathに変更する	os.chdir(os.dirname(filepath))
左三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='<')
色差別ないグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
折れ線グラフを描画して、その色をパールゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='palegoldenrod')
上位集合か	aSet.issuperset(aSet2)
ファイルをバイナリ書き込みモードでオープンして]、fとする	f = open(filepath, mode='wb')
黒いダイアモンドマーカーで散布図を描く	plt.plot(xdata, ydata, marker='D', c='k')
改行	'\n'
黒い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
ダークグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkgrey')
ヒストグラムを描画して、その色をマゼンタに設定する	plt.hist(データ列, color='magenta')
＜オプション＞グラフの色をライトグリーンに設定する	color = 'lightseagreen'
データフレームから指定されたデータ型の列名の一覧を使う	df.select_dtypes(型).columns
イテラブルを文字列リストに変換して、タブで結合する	'\t'.join(map(str, iterable))
折れ線グラフを描画して、色をグリーンイエローにセットする	plt.plot(データ列, データ列2, color='greenyellow')
配列とデータ列について散布図を描画して文字列という補足用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
＜オプション＞グラフの色を小麦色に指定する	color = 'wheat'
データフレームのカテゴリデータをダミー変数に変換する	pd.get_dummies(df)
折れ線グラフを描画して、その色をローングリーンに設定する	plt.plot(データ列, データ列2, color='lawngreen')
ケンドール相関係数でデータフレームの列と列の相関行列	df[[column, column2]].corr(method='kendall')
データフレームのリストカラムの分散	df[aList].var()
ふたつの集合の積集合を求める	aSet.intersection(aSet2)
実数を整数に変換する	int(x)
文字列中に部分文字列がないか調べる	sub not in s
シーケンスを文字列に変換して連結する	''.join(map(str, iterable))
predicateFuncが真となるイテラブルの要素	itertools.takewhile(predicateFunc, iterable)
両端キューのn番目に要素を挿入する	deq.insert(n, element)
両端キューの要素を右にn個分ローテンションする	deq.rotate(n)
データフレームを各列毎にグループ化して、列の分散を計算する	df.groupby(column)[column2].var()
折れ線グラフの色をコーラルに設定する	plt.plot(データ列, データ列2, color='coral')
キーがマッピング上で定義済みか判定する	key in aDict
集合からエラーなく要素を取り除く	aSet.discard(element)
＜オプション＞ライトスカイブルーを使う	color = 'lightskyblue'
プログラムの実行を異常終える	sys.exit(1)
線幅nのダイアモンドマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
折れ線グラフを描画してその色をブルーバイオレットに設定する	plt.plot(データ列, データ列2, color='blueviolet')
暗いを数列とデータ列で描いて、その線幅をnに指定する	plt.plot(xdata, ydata, linestyle='dark', color='r')
折れ線グラフの色をパールゴールデンロッドにセットする	plt.plot(データ列, データ列2, color='palegoldenrod')
ランダムに一行、データフレームから抽出する	df.sample()
折れ線グラフを描画して、その色を暗い赤に設定する	plt.plot(データ列, データ列2, color='darkred')
文字列の中のASCII限定としてパターンによる全マッチを使う	re.findall(pattern, s, flags=re.ASCI)
＜オプション＞色をオレンジに設定する	color = 'orange'
ファイルをデータフレームとして読み込む	pd.read_excel(filename)
複数のデータフレームを縦方向に連結する	pd.concat([df, df2, df3], axis=0)
破線の色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
二変数の最小値	min(x, y)
リストとリストについての散布図にバツマーカーを描画する	plt.plot(xdata, ydata, marker='x')
データフレームを'A'列によってによって降順にソートする	df.sort_values(by='A', ascending=False)
アクアマリン色の線グラフを描画する	plt.plot(データ列, データ列2, color='aquamarine')
ネイビー色のヒストグラムを描画する	plt.hist(データ列, color='navy')
bとn2から成るペア	(n, n2)
日付データが何年か知る	aDate.year
データフレームの指定した列を配列にする	df[column].values
散布図に赤い星マーカーを使う	plt.plot(xdata, ydata, marker='*', c='r')
文字列が組に含まれないかどうか調べる	element not in aTuple
文字列内にひとつでも英数字が含まれるか確認する	any(c.isalnum() for c in s)
線グラフを描画してその色をライトグレーに指定する	plt.plot(データ列, データ列2, color='lightgray')
全ての数字	string.digits
一点鎖線にヒストグラムをセットする	plt.hist(データ列, linestyle='dashbot')
データフレームのリストカラムの欠損値を最大値で補う	df[aList].fillna(df[aList].max())
折れ線グラフを描画して、色をフォレストグリーンにする	plt.plot(データ列, データ列2, color='forestgreen')
データフレームの最後	df.tail()
リストとリストの散布図を色差別ない色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
配列とリストについての散布図に赤色の四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c='r')
文字列を右寄せにする	s.rjust(文字列幅)
標準入力を使う	sys.stdin
データフレームのカラムを十の位で丸めて、整数型にする	df[col].round(-1).astype(int)
＜オプション＞色をライムに設定する	color = 'lime'
オブジェクトはリストかタプルか調べる	isinstance(obj, (list)
空白が文字列内に含まれるかどうか調べる	any(c.isspace() for c in s)
リストとリストでパステル調のを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
ファイルからの入力ストリームを使う	open(filepath)
nをn2で割った余り	n % n2
オブジェクトの参照カウント	sys.getrefcount(obj)
配列を明るい色のヒストグラムとしてプロットする	plt.hist(xdata, color='bright')
データフレームの内の欠損値が存在する行を削除する	df.dropna()
＜オプション＞バイナリ書き込みモードに設定する	mode = 'wb'
配列とリストの散布図に黒い右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>', c='k')
ユニークな値を要素とする配列	np.unique(aArray)
＜オプション＞エンコーディングを文字コードtextに設定する	encoding = text
ヒストグラムの色をライトスカイブルーに設定する	plt.hist(データ列, color='lightskyblue')
スクリプトファイルの絶対パス	os.path.abspath(__file__)
インディアンレッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='indianred')
暗いグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
データフレームのリスト列を千の位で丸める	df[aList].round(-3)
文字列の中で大文字・小文字を無視して正規表現にマッチしたすべての文字列をリストに変換する	re.findall(pattern, s, flags=re.IGNORECASE)
データ列のヒストグラムを描く	plt.hist(ds)
乱数平均と標準偏差からを生成する	random.normalvariate(mu=0.5, sigma=0.2)
ヒストグラムの線のスタイルを実線に設定する	plt.hist(データ列, linestyle='solid')
十六進文字列を整数に変換する	int(s, 16)
日付データと日付データの時間差が何分か知る	(aDate - aDate2).total_seconds()//60
リストとリストについての散布図に赤い大バツマーカーを描画する	plt.plot(xdata, ydata, marker='X', c='r')
空集合を使う	set()
線グラフを描画して、その色をブラックに指定する	plt.plot(データ列, データ列2, color='black')
データフレームの中に文字列とがあるか調べる	df.isin([value, value2])
データフレームのカラムが何秒か見る	df[col].dt.second
データフレームのカラムの曜日の名前	df[col].dt.weekday_name
配列をヒストグラムとして可視化する	plt.hist(aArray)
ヒストグラムを描画してその色をデピンクに設定する	plt.hist(データ列, color='deeppink')
データフレームを形式でJSONLファイルに保存する	df.to_excel(filename)
逆正接を求める	math.atan(x)
濃いグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='deep', color='k')
データフレームのリストカラムを10の位で四捨五入する	df[aList].round(-1)
＜オプション＞シアン色を使う	color = 'cyan'
ヒストグラムの透明度をxに設定する	plt.hist(データ列, alpha=x)
カウンタから最頻出な項目の件数	aCounter.most_common()[1]
実数を切り上げて整数にする	math.ceil(x)
折れ線グラフにダイアモンドマーカーを使う	plt.plot(データ列, データ列2, marker='D')
グレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='grey')
暗いグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
箱ひげ図を二つ並べてプロットする	plt.boxplot([データ列, データ列2])
リストとリストの折れ線グラフを描画する	plt.plot(xdata, ydata)
文字列を走査し、正規表現に複数行対応としてマッチするか見る	re.search(pattern, s, flags=re.MULTILINE)
＜オプション＞ラベンダーブラッシュ色を使う	color = 'lavenderblush'
リストとリストについての散布図を濃い色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
折れ線グラフの色をパウダーブルーにする	plt.plot(データ列, データ列2, color='powderblue')
データフレームの欠損値を最大値で埋める	df.fillna(df.max())
部分文字列を範囲を指定して探す	s.find(sub, start, end)
predicateFuncが真になるシーケンスの部分	itertools.dropwhile(predicateFunc, iterable)
ヒストグラムの色をディムグレーに設定する	plt.hist(データ列, color='dimgrey')
配列の最大値	np.max(aArray)
黒色の大バツマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='X', c='k')
折れ線グラフを描画して、その色を濃い青にする	plt.plot(データ列, データ列2, color='darkblue')
文字列全体をASCII限定として正規表現にマッチさせる	re.fullmatch(pattern, s, flags=re.ASCI)
数列と配列のカラーコードの明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
自然数のGCD	math.gcd(n, n2)
線グラフを描画して、色をモカシンに設定する	plt.plot(データ列, データ列2, color='moccasin')
データフレームのリスト列がどれだけ、分散しているか見る	df[aList].var()
折れ線グラフを描画してその色をサンディーブラウンに設定する	plt.plot(データ列, データ列2, color='sandybrown')
折れ線グラフを描画してその色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgray')
シーケンスからn個サンプリングする	random.sample(iterable, k=n)
nをn2で整数除算する	n // n2
ヒストグラムを明るい色で描画する	plt.hist(xdata, color='bright')
TSVファイルからCSVファイルをSJISで読み込む	pd.read_csv(filename, encoding='shift_jis')
実数を百の位で四捨五入する	round(x, -2)
パステル調のの色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
ヒストグラムを描画して、その色をミディアムブルーにする	plt.hist(データ列, color='mediumblue')
黒い△マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
折れ線グラフの色をダークスラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategray')
組の最初	aTuple[0]
データフレームの列の欠損値を最小値に減らす	df[col].fillna(df[col].min())
＜オプション＞ダークグリーン色を用いる	color = 'darkgreen'
リストとリストの濃いグラフを描いて、色を青色に設定する	plt.plot(xdata, ydata, linestyle='deep', color='b')
折れ線グラフを描画してその色をダークターコイズに設定する	plt.plot(データ列, データ列2, color='darkturquoise')
二つの数値をプリントする	print(value, value2)
折れ線グラフの色をライトブルーにする	plt.plot(データ列, データ列2, color='lightblue')
データフレームのn行より後ろ抽出する	df[n:]
イテラブルとイテラブルについて散布図をプロットし、四角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='s', c=rgb)
線グラフを描画して、色をパレットトルコイズに設定する	plt.plot(データ列, データ列2, color='paleturquoise')
双方向キューの末尾から値を取り出す	deq.pop()
リストは少なくともひとつ真	any(aList)
データフレームの列名リストで指定された列を削除する	df.drop(columns, axis=1)
データフレームからn行をランダムに抽出する	df.sample(n)
JSONLファイルをデータフレームとして読み込む	pd.read_json(filename, orient='records', lines=True)
データフレームの中に存在する日付データの合計を数える	df.isin([value]).sum()
日付時刻データが日付時刻データよりあと	aDatetime > aDatetime2
＜オプション＞ゴールドにグラフの色を設定する	color = 'gold'
オプションで標準エラーを出力にする	file = sys.stderr
リストの中の最小値	min(aList)
ヒストグラムを描画して、その色をパパイヤウィップに設定する	plt.hist(データ列, color='papayawhip')
データフレームのカラムのpercent分位数	df[col].quantile(percent/100)
明るい色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
二つの文字列を辞書順で比較する	s < s2
UTF8として追加できるようにファイルをオープンする]	open(filepath, mode='a', encoding='utf-8')
要素が辞書の値に含まれていないか調べる	element not in aDict.values()
折れ線グラフを描画して、色をシアンにする	plt.plot(データ列, データ列2, color='cyan')
オブジェクトは整数かどうか調べる	isinstance(obj, int)
nとn2の積	n * n2
パステル調のカラーパレットをグラフの描画で使用する	sns.set(pallete='pastel')
折れ線グラフを描画して、その色をミディアムブルーに変更する	plt.plot(データ列, データ列2, color='mediumblue')
TSVファイルをSJISで読み込む	pd.read_csv(filename, encoding='shift_jis')
データフレームを表示するとき、小数点以下の表示精度を設定する	pd.set_option('precision', n)
文字列リストを結合して一つの文字列にする	''.join(aStringList)
データフレームを列でまとめたグループ	df.groupby(column)
Pandasでデータフレームのcollのエポック秒から日付データに変換する	pd.to_datetime(df[col], unit='s', utc=True)
データフレームのカラムの平均	df[col].mean()
リストとデータ列について散布図を描画してマーカーを四角にする	plt.plot(xdata, ydata, marker='s')
リストとリストの折れ線グラフを描画して、untitledとラベル付けする	plt.plot(xdata, ydata, label=untitled)
散布図のマーカーの大きさを指定する	plt.scatter(xdata, ydata, s=n)
ケンドールとしてデータフレームのリスト列の相関行列を求める	df[aList].corr(method='kendall')
事前に複数行対応として正規表現をコンパイルする	re.compile(pattern, flag=re.MULTILINE)
＜オプション＞ゴールデンロッド色を使う	color = 'goldenrod'
文字列が全て空白からなるか調べる	s.isspace()
データフレームの数値をまとめて丸める	df.round()
＜オプション＞UTF8を使う	encoding = 'utf-8'
日付時刻データと日付時刻データの時間差が何分か知る	(aDatetime - aDatetime2).total_seconds()//60
リストをランダムにシャッフルする	random.shuffle(aList)
アヤメのデータセットをロードする	sns.load_dataset('iris')
直前の値でデータフレームのリストカラムの欠損値を埋める	df[aList].fillna(method='ffill')
nが偶数	n % 2 == 0
リストとリストについて色差別ない色の折れ線グラフを描画し、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
Pandasで、文字列のエポック秒からPandasの日付型に変換する	pd.to_datetime(s, unit='s', utc=True)
＜オプション＞ベージュ色を使用する	color = 'beige'
year年の日付	datetime.date(year=year, month=1, day=1)
黒い左三角マーカーで散布図を描く	plt.plot(xdata, ydata, marker='<', c='k')
カラムを1000の位で丸めて整数型にする	ds.round(-3).astype(int)
文字列の中でASCII限定として正規表現にマッチした全文字列をリストにする	re.findall(pattern, s, flags=re.ASCI)
データフレームの要約統計量	df.describe()
文字列を緑色でプリントする	print(f'\033[32m{value}\033[0m')
文字列が全て大文字かどうか調べる	s.isupper()
リストと配列についての散布図を濃い色で重なりを見やすく描く	plt.plot(xdata, ydata, c='deep', alpha=0.5)
プラットフォームの符号付き整数の最大値	sys.maxsize
＜オプション＞色をイエローグリーンに指定する	color = 'yellowgreen'
折れ線グラフの四角印を青くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='b')
文字列全体が正規表現に大文字・小文字を無視してマッチするか調べる	re.fullmatch(pattern, s, flags=re.IGNORECASE)
＜オプション＞イエローグリーン色を使う	color = 'yellowgreen'
赤色のダイアモンドマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='D', c='r')
色差別ない色のマーカーとして散布図を描画する	plt.plot(xdata, ydata, c='colorblind')
＜オプション＞グラフの色をライトサーモンに指定する	color = 'lightsalmon'
predicateFuncを適用したとき真になるイテラブルの要素を除去する	itertools.dropwhile(predicateFunc, iterable)
データフレームの列がxより大きい行を抽出する	df[df[column] > x]
リストの文字列が最初に見つかるインデックス	aList.index(element)
データフレームを各列毎に集約して、列の標準偏差を計算する	df.groupby(column)[column2].std()
ピアソン相関係数でデータフレームの相関行列	df.corr(method='pearson')
リストのn番目からn2番目までの部分	aList[n:n2]
ヒストグラムを描画して、その色をライトゴールドロディイエローに設定する	plt.hist(データ列, color='lightgoldenrodyellow')
＜オプション＞グラフの色をアクアマリンに設定する	color = 'aquamarine'
データ列を折れ線グラフに描画して、マーカーをポイント印にする	plt.plot(データ列, データ列2, marker='.')
赤い右三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='>', c='r')
折れ線グラフを描画して、その色をミントクリームに設定する	plt.plot(データ列, データ列2, color='mintcream')
折れ線グラフを描画して、色をレベッカパープルに設定する	plt.plot(データ列, データ列2, color='rebeccapurple')
文字列の開始位置からと終了位置の間に部分文字列が含まれる	s.find(sub, start, end) != -1
にx=0の破線を付ける	plt.axvline(x=0, linestyle='dashed')
ライトシアン色のヒストグラムを描画する	plt.hist(データ列, color='lightcyan')
コマンドの第２引数	sys.argv[1]
＜オプション＞ミディアムオーキッドを使用する	color = 'mediumorchid'
データフレームを二つの列によってで破壊的に並べ直す	df.sort_values(by=['A', 'B'], inplace=True)
数の三乗	x ** 3
データフレームのカラムの空文字をNaNに変換し、ドロップする	df[col].replace('', np.nan).dropna()
二進文字列をbytesizeバイトのバイト列にする	int(s, 2).to_bytes(length=bytesize, byteorder='big')
＜オプション＞三角マーカーを使う	marker = '^'
ヒストグラムを描画してその色をレベッカパープルに変更する	plt.hist(データ列, color='rebeccapurple')
リストとリストについて散布図を描画して、マーカーの色をパステル調のに設定する	plt.plot(xdata, ydata, c='pastel')
文字列からformatのパターンで日付時刻に変換する	datetime.datetime.strptime(日付の書かれた文字列, format)
最小値で列の欠損値を埋める	ds.fillna(ds.min())
startからendの範囲のヒストグラムを用いてリストを描画する	plt.hist(データ列, range=(start, end))
データフレームを'A'列によってによって降順に並べる	df.sort_values(by='A', ascending=False)
データ列の中に文字列とがいくつあるか求める	ds.isin([value, value2]).sum()
データフレームのリストカラムの欠損値をxに設定する	df[aList].fillna(x)
ベージュ色のヒストグラムを描画する	plt.hist(データ列, color='beige')
散布図を赤い左三角マーカーで描く	plt.plot(xdata, ydata, marker='<', c='r')
直後の値でデータ列の欠損値を埋める	ds.fillna(method='bfill')
ふたつの関係が真上位集合	aSet > aSet2
折れ線グラフを描画して、色をスラグレーに指定する	plt.plot(データ列, データ列2, color='slategray')
数列とデータ列についての散布図にカラーコードのダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c=rgb)
折れ線グラフの色をカデットブルーに設定する	plt.plot(データ列, データ列2, color='cadetblue')
折れ線グラフの丸マーカーを赤くする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='r')
折れ線グラフに赤い▼マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='r')
イテラブルからひとつランダムに選ぶ	random.choice(iterable)
符号付きでnを長さn2のバイナリに変換する	n.to_bytes(length=bytesize, byteorder='big', signed=True)
セットから要素を取り除く	aSet.remove(element)
Pythonパスにを追加する	sys.path.append(dir)
タプルの要素を昇順に並べ直す	sorted(aTuple, reverse=True)
＜オプション＞色をダークグレーに変更する	color = 'darkgray'
組は全て真か調べる	all(aTuple)
文字列が漢字か判定する	('\u4E00' <= ch <= '\u9FD0')
リストとリストについての散布図に黒い四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c='k')
数値を青色化する	f'\033[34m{value}\033[0m'
折れ線グラフを描画して、その色をダークオリーブグリーンに設定する	plt.plot(データ列, データ列2, color='darkolivegreen')
中央値でデータ列をビン分割する	pd.qcut(ds, 2)
文字列から部分文字列を除去する	s.replace(sub, '')
ヒストグラムの色をスチールブルーに変更する	plt.hist(データ列, color='steelblue')
カラムのNaNを平均値に設定する	ds.fillna(ds.mean())
折れ線グラフを描画して、その色を茶色に指定する	plt.plot(データ列, データ列2, color='brown')
データフレームのカラムのどの値が頻出か見る	df[col].mode()
スーパーセットもしくは等しいか確認する	aSet > aSet2
データフレームの列と列の相関行列をヒートマップで描画する	sns.heatmap(df[[column, column2]].corr())
本日が何日か知る	datetime.datetime.today().day
オブジェクトは浮動小数点数クラスか調べる	isinstance(obj, float)
数列と数列の明るいを描き、、色を青くする	plt.plot(xdata, ydata, linestyle='bright', color='b')
データフレームの未入力値を直前の値に設定する	df.fillna(method='ffill')
線グラフを描画して、その色をダーク・スラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategrey')
等差数列から整数乱数を生成する	random.randrange(start, end, step)
文字列が全て小文字か調べる	s.islower()
＜オプション＞グラフの色をライトグリーンに設定する	color = 'lightgreen'
文字列を走査し、正規表現にASCII限定としてマッチするか確認する	re.search(pattern, s, flags=re.ASCI)
ヒストグラムを描画して、その色をリネンに設定する	plt.hist(データ列, color='linen')
エクセルデータファイルから複数のシートを読み込む	pd.read_excel(filename, sheet_name=[n, n2])
リストとリストについて散布図を描画して、マーカーを星に設定する	plt.plot(xdata, ydata, marker='*')
プロットのタイトルを変更する	plt.title(untitled)
1からnまでの整数列	list(range(1, n+1))
直前の値でデータフレームの未入力値を埋める	df.fillna(method='ffill')
ヒストグラムを描画して、その色をレモンシフォンに設定する	plt.hist(データ列, color='lemonchiffon')
範囲を指定して整数乱数を求める	random.randint(最小値, 最大値)
nが一桁の数か	0 <= n <= 9
数を整数に変換する	int(x)
濃いグラフの色を青にする	plt.plot(xdata, ydata, linestyle='deep', color='b')
文字列をUTF8でバイト列に変換する	s.encode(encoding='utf-8', errors='strict')
辞書をJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False)
データフレームのリストカラムが正規分布からどの程度、歪んでいるか確認する	df[aList].kurt()
データフレームのリスト列の中に日付データがある	df[aList].isin([value])
TSVからデータフレームを読み込む	pd.read_csv(filename, sep='\t')
配列とリストの折れ線グラフを描画する	plt.plot(xdata, ydata)
折れ線グラフに線幅nの四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markeredgewidth=n)
ヒストグラムの色をモカシンに設定する	plt.hist(データ列, color='moccasin')
データ列の秒	ds.dt.second
データフレームの欠損値を後の行の値で埋める	df.fillna(method='bfill')
nとkのコンビネーション	math.comb(n, k)
データフレームのリストカラムの欠損値を最頻値に設定する	df[aList].fillna(df[aList].mode().iloc[0])
＜オプション＞チョコレートにグラフの色を変更する	color = 'chocolate'
線幅nの大バツ印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='X', markeredgewidth=n)
グラフの描画で色差別ないカラーパレットを使う	sns.set(pallete='colorblind')
ファイルからn文字読み込む	f.read(n)
タプルを反転する	reversed(aTuple)
データフレームを列によってによって降順にソートする	df.sort_values(by=column, ascending=False)
データフレームの中に文字列があるかどうか	df.isin([value])
プロットの見た目を綺麗にする	import seaborn as sns
＜オプション＞昇順にする	ascending = True
データフレームの行の名前をまとめて、nameからname2に変更する	df.rename(index={name: name2})
オブジェクトをデバッグ向けの文字列に変換する	repr(obj)
＜オプション＞右三角マーカーを用いる	marker = '>'
＜オプション＞グラフの色をディムグレーに設定する	color = 'dimgrey'
ヒストグラムの色をブルーバイオレットに設定する	plt.hist(データ列, color='blueviolet')
エクセルファイルファイルからエクセルファイルを読み込む	pd.read_excel(filename)
ヒストグラムを実線に指定する	plt.hist(データ列, linestyle='solid')
＜オプション＞色をスカイブルーに設定する	color = 'skyblue'
カラーコードの丸マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='o', c=rgb)
辞書を階層化する	collections.ChainMap(aDict)
淡いの色を青くする	plt.plot(xdata, ydata, linestyle='muted', color='b')
ヒストグラムを描画して、その色をホットピンクに設定する	plt.hist(データ列, color='hotpink')
ダーク・スラテグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkslategrey')
シーケンスの長さnの順列	itertools.permutations(iterable, n)
散布図を赤い三角マーカーを使って描く	plt.plot(xdata, ydata, marker='^', c='r')
変数を青色でプリントできる文字列に変換する	f'\033[34m{value}\033[0m'
＜オプション＞ライトグリーン色を使う	color = 'lightseagreen'
データフレームを列ごとにグループ分けして、それぞれのグループ毎の平均値を求める	df.groupby(column).mean()
データフレームの中にある文字列の合計を数える	df.isin([value]).sum()
ヒストグラムのビンを設定する	plt.hist(データ列, bins=n)
折れ線グラフの色をライムに設定する	plt.plot(データ列, データ列2, color='lime')
CSVファイルTSVファイルをn番目の列を行として読む	pd.read_csv(filename, index_col=n)
既存のファイルを文字列の示すエンコーディングで追加できるようにオープンする]	open(filepath, mode='a', encoding=s)
濃いの折れ線グラフの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
Pandasで、フォーマットfmtでデータ列を日付データに変換する	pd.to_datetime(ds, format=fmt)
集合から任意の要素を取り出す	aSet.pop()
日付データの月を使う	aDate.month
＜オプション＞読み込まない列番号をnamesで指定する	skiprows = names
nとn2の値を足してnに代入する	n += n2
折れ線グラフを描画して色をビスクに設定する	plt.plot(データ列, データ列2, color='bisque')
ヒストグラムを描画して、その色をオーキッドに設定する	plt.hist(データ列, color='orchid')
折れ線グラフの色をナバホホワイトに設定する	plt.plot(データ列, データ列2, color='navajowhite')
散布図を左三角マーカーを使って描画する	plt.plot(xdata, ydata, marker='<')
＜オプション＞セパレータをカンマにする	sep = ','
色差別ない色を用いて散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
データフレームを列によって昇順に並べる	df.sort_values(by=column, ascending=True)
オブジェクトは辞書クラスか調べる	isinstance(obj, dict)
ファイルに文字列を書き込む	f.write(s)
何回まで再帰ができるかを	sys.getrecursionlimit()
リストとリストで濃いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', color='r')
リストと配列について破線グラフを描画し、、その色をパステル調のに設定する	plt.plot(xdata, ydata, linestyle='dash', color='pastel')
本日をタプルにする	datetime.datetime.today().timetuple()
行列の列ごとの標準偏差を算出する	np.std(aArray, axis=0)
組を逆さにする	reversed(aTuple)
リストとリストのパステル調のグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='pastel', color='k')
ヒストグラムのアルファをxに設定する	plt.hist(データ列, alpha=x)
リストとリストについて淡いグラフを描画し、その色を黒にする	plt.plot(xdata, ydata, linestyle='muted', color='k')
文字列の開始位置から終了位置の範囲で部分文字列の出現をカウントする	s.count(sub, start, end)
データフレームから型のみ抽出する	df.select_dtypes(ty)
辞書のキーとその値をペアとして取り出す	aDict.items()
日付データからn日を減算する	aDate - datetime.timedelta(days=n)
値を青色でプリントする	print(f'\033[34m{value}\033[0m')
線グラフの色を茶色に設定する	plt.plot(データ列, データ列2, color='brown')
代数計算モジュールを使用する	import sympy
真部分集合か調べる	aSet < aSet2
整数個からk個取り出した場合の順列の総数を求める	math.perm(n, k)
ベクトルの演算を行う	import numpy as np
文字をユニコードにする	ord(ch)
文字列がアスキー文字か調べる	s.isascii()
折れ線グラフのスタイルを破線に設定する	plt.plot(データ列, データ列2, linestyle='dashed')
ファイルの拡張子なしのファイル名	os.path.splitext(os.path.basename(filepath))[0]
文字列を記号に変換する	sympy.Symbol(s)
Pandasで、dateStringを日付データに変換する	pd.to_datetime(dateString)
ライトスチールブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightsteelblue')
＜オプション＞グラフの色をカーキに設定する	color = 'khaki'
ヒストグラムの色をスラグレーに設定する	plt.hist(データ列, color='slategray')
リストの要素をスワップする	aList[i], aList[j] = aList[j], aList[i]
nからn2の値を引いてnとする	n -= n2
kを底とする対数を求める	math.log(x, k)
等量でデータ列をn個にビンニングする	pd.qcut(ds, n)
イテラブルから計数器を生成する	collections.Counter(iterable)
数列と数列の青い暗いグラフを描く	plt.plot(xdata, ydata, linestyle='dark', color='b')
赤い濃いの折れ線グラフをプロットする	plt.plot(xdata, ydata, linestyle='deep', color='r')
nにn2をかけた値をnに代入する	n *= n2
カウンタの項目を、その回数だけリストとして得る	aCounter.elements()
データフレームの尖度	df.skew()
コーラル色の線グラフを描画する	plt.plot(データ列, データ列2, color='coral')
リストとリストについての散布図に大バツマーカーを描画する	plt.plot(xdata, ydata, marker='X')
＜オプション＞三二ビット整数型を使う	dtype = np.int16
線グラフを描画して、色を青に設定する	plt.plot(データ列, データ列2, color='blue')
＜オプション＞線種を一点鎖線に指定する	linestyle = 'dashbot'
折れ線グラフを描画して、色をダークグリーンに変更する	plt.plot(データ列, データ列2, color='darkgreen')
両端キューに値をスタックする	deq.append(element)
両端キューの末尾	deq[-1]
配列の累積積	np.cumprod(aArray)
グラフの凡例の位置を指定する	plt.legend(loc=(x, y))
データフレームのカラムの欠損値を平均値に設定する	df[col].fillna(df[col].mean())
二つの浮動小数点数が近似値か調べる	math.isclose(x, x2)
ヒストグラムを描画して、その色をタンに変更する	plt.hist(データ列, color='tan')
データフレームのリストカラムがどの程度、分散しているか見る	df[aList].var()
n割るmの有理数表現	fractions.Fraction(numerator=n, denominator=m)
要素が全て1のベクトル	np.ones(要素数, dtype=np.int)
リストとリストについての散布図に赤いダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c='r')
カラーコードの四角マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='s', c=rgb)
モードでデータフレームのカラムの欠損値を埋める	df[col].fillna(df[col].mode().iloc[0])
散布図に色差別ない色のマーカーを用いる	plt.plot(xdata, ydata, c='colorblind')
リストのn番目の	aList[n]
ヒストグラムの色をダークオーキッドに設定する	plt.hist(データ列, color='darkorchid')
グリッド線をグラフに入れる	plt.grid(True)
既存のファイルをBOM付きで追加できるようにオープンする]	open(filepath, mode='a', encoding='utf_8_sig')
線グラフを描画してその色をブルーバイオレットに変更する	plt.plot(データ列, データ列2, color='blueviolet')
配列と数列について散布図を描画して、ポイントマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='.', c=rgb)
ヒストグラムを描画して、その色をブラックに設定する	plt.hist(データ列, color='black')
＜オプション＞グラフの色をオーキッドに設定する	color = 'orchid'
折れ線グラフを描画して、色をライムグリーンに指定する	plt.plot(データ列, データ列2, color='limegreen')
リストと数列の散布図にポイントマーカーを描く	plt.plot(xdata, ydata, marker='.')
ファイルパスを文字列の示すエンコーディングを用いてオープンする]	open(filepath, encoding=s)
セットをリストに変換する	list(aSet)
＜オプション＞小麦色にグラフの色を変更する	color = 'wheat'
データフレームを関数の値によって集約する	df.groupby(関数)
データフレームの中に日付データと文字列が存在するか調べる	df.isin([value, value2])
折れ線グラフの右三角マーカーを黒くする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='k')
ファイルパスをバイナリ書き込みモードとしてオープンして]、fとする	f = open(filepath, mode='wb')
ヒストグラムを描画して、色をラベンダーブラッシュに設定する	plt.hist(データ列, color='lavenderblush')
リストとリストの散布図に赤い星マーカーをプロットする	plt.plot(xdata, ydata, marker='*', c='r')
日付時刻データからn分、減算する	aDatetime - datetime.timedelta(minutes=n)
xに棒グラフの幅を設定する	plt.bar(ラベル列, データ列, width=x)
データフレームの内で、列と列の重複を消す	df.drop_duplicates(subset=[column, column2])
行列の要素ごとのアダマール積	np.multiply(aArray, aArray2)
本日の日付時刻	datetime.datetime.today()
配列をn個に分割して、namesのラベルをつける	pd.cut(aArray, n, labels=names)
リストとリストについて破線を描画して、その色を淡いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
'A'列でデータフレームをまとめたグループ	df.groupby('A')
＜オプション＞青緑色を使う	color = 'teal'
データフレームを表示するとき、小数点以下の表示精度をn桁に設定する	pd.set_option('precision', n)
＜オプション＞オレンジレッド色を用いる	color = 'orangered'
綺麗なプロットを描画する準備をする	import seaborn as sns
リストと数列についての散布図にダイアモンドマーカーをプロットする	plt.plot(xdata, ydata, marker='D')
整数nのバイト長	(n.bit_length() + 7) // 8
折れ線グラフの大バツマーカーを緑色にする	plt.plot(データ列, データ列2, marker='X', markerfacecolor='g')
データ列を箱ひげ図で描画する	plt.boxplot(データ列)
行列を2次元1行に変形する	aArray.reshape(1, -1)
ファイルを絶対パスにする	os.path.abspath(filepath)
散布図をカラーコードの右三角マーカーを用いて描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
データフレームを'A'列の値によってグループ化し、要約統計量を求める	df.groupby('A').describe()
Pythonのバージョン	sys.version
双方向キューの先頭から要素を取り出す	deq.popleft()
既存のファイルをSJISで追加できるようにオープンする]	open(filepath, mode='a', encoding='shift_jis')
計算機イプシロンを計算する	sys.float_info.epsilon
0からnの範囲	range(n)
折れ線グラフを描画する	plt.plot(xdata, ydata)
データフレームのリストカラムの中にいくつ文字列があるか数える	df[aList].isin([value]).sum()
黒い丸マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='o', c='k')
線グラフを描画して、その色をミディアムバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='mediumvioletred')
原点から点までの距離	math.hypot(x, y)
オブジェクトは数値か調べる	isinstance(obj, (int,float))
リストとリストの折れ線グラフを描画して、その色をカラーコードに設定する	plt.plot(xdata, ydata, color=rgb)
＜オプション＞グリーン色を使う	color = 'green'
データフレームのカラムの第一四分位数を求める	df[col].quantile(0.25)
列をキーにして二つのデータフレームを全結合する	pd.merge(df, df2, on=column, how='outer')
実数を十の位で丸める	round(x, -1)
ヒストグラムを描画して、その色をライトブルーに指定する	plt.hist(データ列, color='lightblue')
＜オプション＞ミディアムオーキッドを使う	color = 'mediumorchid'
ヒストグラムの色を紺に設定する	plt.hist(データ列, color='darkblue')
折れ線グラフの色をインディゴに指定する	plt.plot(データ列, データ列2, color='indigo')
＜オプション＞ライトゴールドロディイエローにグラフの色を変更する	color = 'lightgoldenrodyellow'
ヒストグラムの色をトマトに設定する	plt.hist(データ列, color='tomato')
ヒストグラムを描画して、その色をスレートブルーに設定する	plt.hist(データ列, color='slateblue')
配列の標準偏差	np.std(aArray)
文字列中から部分文字列を探す	s.find(sub)
グラフにy=0の破線を付ける	plt.axhline(y=0, linestyle='dashed')
オブジェクトは文字列クラスか調べる	isinstance(obj, str)
文字列が正規表現にマッチさせる	re.match(pattern, s)
オブジェクトはタプルの要素でないかどうか調べる	element not in aTuple
データフレームのカラムの中にいくつ欠損値があるかカウントする	df[col].isna().sum()
リストと配列についての散布図を大きさnで描画する	plt.scatter(xdata, ydata, s=n)
配列と配列を折れ線グラフで描画する	plt.plot(xdata, ydata)
文字化けしないようにタブ区切りのファイルを読み込む	pd.read_csv(filename, encoding='shift_jis')
ファイルを文字コードtextとしてオープンする]	open(filepath, encoding=text)
赤い左三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='<', c='r')
＜オプション＞グラフの色を白に設定する	color = 'white'
＜オプション＞グラフの色をグレーにする	color = 'gray'
両端キューのn番目	deq[n]
折れ線グラフを描画して、その色を茶色に設定する	plt.plot(データ列, データ列2, color='brown')
リストとリストの青い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='b')
文字列が無限に繰り返すイテラブル	itertools.repeat(element)
osモジュールをインポートする	import os
折れ線グラフに緑色の星印を描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='g')
ヒストグラムを描画してその色をホットピンクに設定する	plt.hist(データ列, color='hotpink')
ユーザから入力される	input()
重複を認めてn行をランダムにデータフレームからサンプリングする	df.sample(n, replace=True)
リストとリストの黒い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='k')
ヒストグラムを描画して、その色をダークバイオレットにセットする	plt.hist(データ列, color='darkviolet')
タプルをネスト化する	collections.ChainMap(aDict)
Pandasで、データフレームのcollを日付データにする	pd.to_datetime(df[col])
ゼロ埋めされた配列を作る	np.zeros(要素数)
配列とリストについて散布図を描画して、右三角マーカーの色をカラーコードに変更する	plt.plot(xdata, ydata, marker='>', c=rgb)
線グラフを描画してその色をローングリーンに指定する	plt.plot(データ列, データ列2, color='lawngreen')
スピアマン相関係数でデータフレームのリストで指定された列の相関行列を算出する	df[aList].corr(method='spearman')
ヒストグラムを描画して、その色をナバホホワイトに設定する	plt.hist(データ列, color='navajowhite')
カラーコードの下三角マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='v', c=rgb)
＜オプション＞色をライトコーラルに設定する	color = 'lightcoral'
データフレームのリスト列の中の欠損値の数をカウントする	df[aList].isna().sum()
＜オプション＞色をリネンに変更する	color = 'linen'
データフレームから重複したデータをドロップして、更新する	df.drop_duplicates(inplace=True)
昇順に列によってデータフレームをソートし、、更新する	df.sort_values(by=column, ascending=True, inplace=True)
データフレームから列を二つだけ選択する	df[[column, column2]]
ファイルパスを文字列の示すエンコーディングとして書き込み用に開く]	open(filepath, mode='w', encoding=s)
データフレームの空文字をNaNに変換し、ドロップする	df.replace('', np.nan).dropna()
ファイルをSJISを使って書き込みできるようにオープンする]	open(filepath, mode='w', encoding='shift_jis')
折れ線グラフを描画して、その色をインディゴに設定する	plt.plot(データ列, データ列2, color='indigo')
日付時刻データと日付時刻データの時間差	aDatetime - aDatetime2
ヒストグラムを描画して、その色をグレーに設定する	plt.hist(データ列, color='gray')
ベクトルの形	aArray.shape
n割るn2を切り上げる	(n + n2 - 1) // n2
データフレームの中の列をビン数nでビン分割して、namesのラベルをつける	pd.cut(df[col], n, labels=names)
リストと配列について青いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='b')
オブジェクトのバイトサイズを知る	sys.getsizeof(obj)
散布図にカラーコードのバツマーカーを使う	plt.plot(xdata, ydata, marker='x', c=rgb)
赤色の大バツマーカーをリストと数列についての散布図に描画する	plt.plot(xdata, ydata, marker='X', c='r')
文字列の先頭の文字を使う	s[0]
データフレームの列がx、かつ列がx2である行を抽出する	df[(df[column] == x) & (df[column2] == x2)]
リストとデータ列の明るいグラフを描いて、色を青にする	plt.plot(xdata, ydata, linestyle='bright', color='b')
カラーコードの丸マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='o', c=rgb)
濃い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='deep')
黒い下三角マーカーをリストとリストの散布図に描く	plt.plot(xdata, ydata, marker='v', c='k')
year年month月day日hour時minute分を日付時刻に変換する	datetime.datetime(year=year, month=month, day=day, hour=hour, minute=minute)
文字列を文字リストに変換する	list(s)
データフレームのカラムの値をValueMapでまとめて置き換える	df[col].replace(ValueMap)
英字の大文字を全て使う	string.ascii_uppercase
＜オプション＞グラフの色をシエナに指定する	color = 'sienna'
グラフの描画で濃いカラーパレットを使う	sns.set(pallete='deep')
データフレームを２つの列によって昇順にソートする	df.sort_values(by=['A', 'B'], ascending=True)
ヒストグラムを描画して、色をダークサーモンに設定する	plt.hist(データ列, color='darksalmon')
＜オプション＞グラフの色をダークスレートブルーに設定する	color = 'darkslateblue'
＜オプション＞色をスチールブルーに設定する	color = 'steelblue'
JSON形式のバイト列を辞書に変換する	json.loads(b.decode('unicode-escape'))
マゼンタ色のヒストグラムを描画する	plt.hist(データ列, color='magenta')
文字列の中の複数行対応として正規表現による全てのマッチを使う	re.findall(pattern, s, flags=re.MULTILINE)
星マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='*')
未定値	None
ファイルパスをBOM付きで追加できるようにオープンする]	open(filepath, mode='a', encoding='utf_8_sig')
リストとデータ列を使って暗いグラフをプロットしてその線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
浮動小数点数の逆正弦を求める	math.asin(x)
グラフの見栄えをデフォルトでいい感じに設定する	sns.set()
折れ線グラフに赤い左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='r')
データ列とデータ列から重複を取り除く	set(ds.unique().tolist()+ds2.unique().tolist())
＜オプション＞色をミントクリームにセットする	color = 'mintcream'
折れ線グラフの色をホットピンクに設定する	plt.plot(データ列, データ列2, color='hotpink')
文字列が部分文字列で終わるか調べる	s.endswith(sub)
配列とデータ列の散布図に左三角マーカーを描く	plt.plot(xdata, ydata, marker='<')
実行結果をアンダーライン付きにする	f'\033[4m{value}\033[0m'
折れ線グラフのマーカーを大バツにする	plt.plot(データ列, データ列2, marker='X')
文字列の先頭から部分文字列を探す	s.find(sub)
データフレームを二つの列によって昇順にソートして、更新する	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
赤いポイントマーカーで散布図を描く	plt.plot(xdata, ydata, marker='.', c='r')
赤色で文字列を出力する	print(f'\033[31m{value}\033[0m')
配列と数列について散布図を描画して、丸マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='o', c=rgb)
＜オプション＞追加用に設定する	mode = 'a'
オブジェクトのハッシュ値	hash(obj)
線グラフを描画してその色をブランチドアーモンドに指定する	plt.plot(データ列, データ列2, color='blanchedalmond')
ヒストグラムの色をミディアムパープルに設定する	plt.hist(データ列, color='mediumpurple')
改行で文字列を区切り、文字列リストにする	s.splitlines()
折れ線グラフを描画して、色をホワイトスモークに設定する	plt.plot(データ列, データ列2, color='whitesmoke')
数式のインテグラルを行う	sympy.integrate(e)
数から実数を引く	x - y
折れ線グラフの星マーカーを黒色にする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='k')
浮動小数点数の二乗	x ** 2
リストとリストの淡いグラフを描画し、色を青にする	plt.plot(xdata, ydata, linestyle='muted', color='b')
折れ線グラフの色をライトグリーンに設定する	plt.plot(データ列, データ列2, color='lightgreen')
配列を四分位数ごとにビン分割する	pd.qcut(aArray, 4)
項目名ワード引数としてタプルに加えて、更新する	aDict.update(**kwargs)
パレットトルコイズ色のヒストグラムを描画する	plt.hist(データ列, color='paleturquoise')
現在の日数	datetime.datetime.today().day
ヒストグラムを描画して、色をバリーウッドに設定する	plt.hist(データ列, color='burlywood')
折れ線グラフの色をライトグレーに設定する	plt.plot(データ列, データ列2, color='lightgray')
リストとリストについて破線グラフを描画して、その色を明るいに設定する	plt.plot(xdata, ydata, linestyle='dash', color='bright')
パステル調の色でリストとイテラブルについての散布図を描画する	plt.plot(xdata, ydata, c='pastel')
リストのn番目のの要素を見る	aList[n]
ダークオリーブグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkolivegreen')
キーがマッピングにあるか	key not in aDict
ヒストグラムのプロットして、正規化する	plt.hist(データ列, density=True)
＜オプション＞下三角印を描画する	marker = 'v'
列を用いてデータフレームをソートする	df.sort_values(by=column)
ヒストグラムを描画してその色をダークオレンジに設定する	plt.hist(データ列, color='darkorange')
ヒストグラムを描画してその色をドジャーブルーにする	plt.hist(データ列, color='dodgerblue')
2つのタプルをチェーンする	collections.ChainMap(aDict, aDict2)
ピアソン相関係数でデータフレームの列と列の相関行列	df[[column, column2]].corr(method='pearson')
貝殻色の線グラフを描画する	plt.plot(データ列, データ列2, color='seashell')
実数のn乗の整数剰余を計算する	pow(x, n, y)
データフレームのstart行目からend行目までを抽出する	df[start:end]
データフレームを列毎にグループ化して、それぞれのグループごとの合計を計算する	df.groupby(column).sum()
データフレームをJSONLファイルに保存する	df.to_csv(filename)
データフレームのそれぞれのグループごとの最小値	df.groupby(column).min()
＜オプション＞ローングリーン色を使う	color = 'lawngreen'
データフレームのリスト列の要約統計量を求める	df[aList].describe()
0から始まるn個の整数列を作る	list(range(n))
データフレームのリストカラムを百の位で丸めて、整数にする	df[aList].round(-2).astype(int)
ヒストグラムの色をロイヤルブルーに指定する	plt.hist(データ列, color='royalblue')
折れ線グラフの線幅を指定する	plt.plot(xdata, ydata, linewidth=n)
xの小数点以下'2'桁までをプリントする	print(':.2f'.format(x))
リストのn番目以降の部分を取り出す	aList[n:]
集合から要素を取り除く	aSet.remove(element)
＜オプション＞カデットブルー色を使用する	color = 'cadetblue'
ペールグリーン色のヒストグラムを描画する	plt.hist(データ列, color='palegreen')
日付時刻データからn週間分、減算する	aDatetime - datetime.timedelta(weeks=n)
データフレームのカラムの欠損値を最頻値に設定する	df[col].fillna(df[col].mode().iloc[0])
黒い上三角マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='^', c='k')
データ列を丸めて、整数型にする	ds.round().astype(int)
nがn2よりも大きいかどうか調べる	n > n2
PandasでデータフレームのcollのUNIX秒から日付データにする	pd.to_datetime(df[col], unit='s', utc=True)
文字列の開始位置番目と終了位置番目の間に部分文字列が存在しないかどうか調べる	s.find(sub, start, end) == -1
nが正の数	n > 0
グラフの背景色を暗くする	sns.set(style='darkgrid')
マッピングの全をクリアする	aDict.clear()
配列間の要素ごとの最大公約数	np.gcd(aArray, aArray2)
折れ線グラフの右三角印を青くする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='b')
＜オプション＞読むシートの名前をnamesに設定する	sheet_name = names
散布図に黒い左三角マーカーを用いる	plt.plot(xdata, ydata, marker='<', c='k')
データフレームの中の列をリストを境界値としてビン分割する	pd.cut(df[col], aList)
タイムスタンプデータと日付時刻データの時間差を秒数で計算する	(aDatetime - aDatetime2).total_seconds()//60
データフレームのカラムの中に文字列と日付データがいくつ含まれるかカウントする	df[col].isin([value, value2]).sum()
折れ線グラフのバツマーカーを黒くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='k')
今日の日付	datetime.date.today()
シルバー色のヒストグラムを描画する	plt.hist(データ列, color='silver')
＜オプション＞色をオリベドラブに設定する	color = 'olivedrab'
散らばりを可視化する	plt.scatter(xdata, ydata)
前の行の値でデータフレームの欠損値を埋める	df.fillna(method='ffill')
リストを行列にする	np.array(aList)
データフレームを列でグループ化して、列の要約統計量を求める	df.groupby(column).describe()[column2]
＜オプション＞グラフの色をミスティローズに設定する	color = 'mistyrose'
リストの先頭を取り除く	aList[1:]
ブラックにヒストグラムの色を指定する	plt.hist(データ列, color='black')
既存のベクトルを元に全要素が初期値の配列	np.full_like(aArray, 初期値)
nは配列のどれかか調べる	n in aArray
実数を切り下げて整数に変換する	math.floor(x)
折れ線グラフを描画して、その色をパールバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='palevioletred')
実数の小数点以下を四捨五入する	round(x)
数列とリストの散布図に菱形マーカーを描画する	plt.plot(xdata, ydata, marker='D')
線グラフを描画して、その色をライトスカイブルーに変更する	plt.plot(データ列, データ列2, color='lightskyblue')
データフレームから型リストのデータ型の列のみ除外する	df.select_dtypes(exclude=typeList)
JSONファイルのファイルを読み込んでdataとする	data = json.load(fin)
列の一意な値	df[col].unique()
線グラフを描画してその色をスプリンググリーンに設定する	plt.plot(データ列, データ列2, color='springgreen')
＜オプション＞ゴーストホワイト色を使う	color = 'ghostwhite'
文字列の右端から部分文字列を消す	s.removesuffix(sub)
ヒストグラムの色をミントクリームに設定する	plt.hist(データ列, color='mintcream')
折れ線グラフの下三角印を黒色にする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='k')
ファイルを文字列の示すエンコーディングで書き込み用にオープンする]	open(filepath, mode='w', encoding=s)
＜オプション＞グラフの色をダーク・スラテグレーに設定する	color = 'darkslategrey'
サイコロ	random.randint(1, 6)
1からNまでのベクトル	np.arange(1, N+1)
＜オプション＞ディープスカイブルーにグラフの色を指定する	color = 'deepskyblue'
TSVファイルをヘッダを指定せず読み込む	pd.read_csv(filename, header=None)
ヒストグラムを描画して、色をミディアムオーキッドにセットする	plt.hist(データ列, color='mediumorchid')
データフレームのカラムの欠損値を50パーセンタイルに設定する	df[col].fillna(df[col].median())
ファイルからバイナリストリームをオープンして]、fとする	f = open(filepath, mode='rb')
折れ線グラフのバツマーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
文字列中に非数字があるか調べる	any(not c.isdigit() for c in s)
文字列を改行で分割し文字列リストに変換する	s.splitlines()
線グラフを描画して、その色をマゼンタに設定する	plt.plot(データ列, データ列2, color='magenta')
散布図に黒い▽マーカーを使う	plt.plot(xdata, ydata, marker='v', c='k')
＜オプション＞ペールグリーンを使用する	color = 'palegreen'
折れ線グラフを描画してその色を赤に変更する	plt.plot(データ列, データ列2, color='red')
グラフに目盛り線を描画する	plt.grid(True)
実数の複素数	complex(x)
グラフ中の(x,y)の位置に凡例を入れる	plt.legend(loc=(x, y))
＜オプション＞グラフの色をコーンフラワーブルーに設定する	color = 'cornflowerblue'
＜オプション＞グラフの色を赤に指定する	color = 'red'
データ列をリストを境界値としてビン分割する	pd.cut(ds, aList)
折れ線グラフを描画してその色をダークスラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategray')
散布図に大バツマーカーを使う	plt.plot(xdata, ydata, marker='X')
1で全要素を初期化された行列を作る	np.ones(要素数, dtype=np.int)
タプルを展開してプリントする	print(*aTuple)
双方向キューの先頭にシーケンスの各値を追加する	deq.extendleft(iterable)
折れ線グラフを描画して、色をホワイトスモークに変更する	plt.plot(データ列, データ列2, color='whitesmoke')
データフレームのカラムの中にあると文字列の合計をカウントする	df[col].isin([value, value2]).sum()
タブで区切って２つの文字列をプリントする	print(value, value2, sep='\t')
ヒストグラムを描画して、色を黒くする	plt.hist(データ列, color='k')
＜オプション＞EUCを使う	encoding = 'euc_jp'
データ列の尖度	ds.skew()
リストの平均値	sum(aList)/len(aList)
カラーコードのバツマーカーを散布図に使う	plt.plot(xdata, ydata, marker='x', c=rgb)
折れ線グラフのマーカーを丸にする	plt.plot(データ列, データ列2, marker='o')
数列とリストについての散布図を重なりを見やすく明るい色でプロットする	plt.plot(xdata, ydata, c='bright', alpha=0.5)
データ列の中にある文字列と文字列の合計を数える	ds.isin([value, value2]).sum()
リストをカウンタに変換する	collections.Counter(iterable)
データフレームの中にいくつ欠損値があるか数える	df.isna().sum()
配列を等間隔でn個にビン分割する	pd.cut(aArray, n)
ヒストグラムでカラーマップを使用する	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
折れ線グラフを描画してその色をスラグレーに指定する	plt.plot(データ列, データ列2, color='slategray')
データフレームを複数の列によって降順に破壊的にソートする	df.sort_values(by=column, ascending=False, inplace=True)
日付データをISO8601形式の文字列にする	aDate.isoformat()
nかけるn2	n * n2
リストが全て真か調べる	all(aList)
文字列の先頭から空白を取り除く	s.lstrip()
日付時刻データが土曜日か確認する	aDatetime.weekday() == 5
ミディアムスプリンググリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumspringgreen')
ユニークな値を要素とする配列を使う	np.unique(aArray)
辞書からキーの値	aDict.get(key)
折れ線グラフの色をパールバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='palevioletred')
ローングリーンにヒストグラムの色を設定する	plt.hist(データ列, color='lawngreen')
データフレームの列一覧	df.info()
等しい量になるようにn個にリストをビン分割する	pd.qcut(aList, n)
両端キューの先頭	deq[0]
スラグレー色のヒストグラムを描画する	plt.hist(データ列, color='slategray')
リストをビン数nでビニングする	pd.cut(aList, n)
データフレームのリスト列の未入力値を最大値に設定する	df[aList].fillna(df[aList].max())
線グラフを描画して、その色をリネンに設定する	plt.plot(データ列, データ列2, color='linen')
＜オプション＞どのカラムもインデックスに設定しない	index_col = None
プラットホームがMacOS	sys.platform.startswith('darwin')
コードポイントの最大値を調べる	sys.maxunicode
グラフの中に枠なしの補足を入れる	plt.legend(frameon=False)
ファイルをSJISでオープンする]	open(filepath, encoding='shift_jis')
ファイルからファイル名を見る	os.path.basename(filepath)
2つの数値を改行で区切ってプリントする	print(value, value2, sep='\n')
リストとリストについて破線グラフを描き、、その色を淡いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
ファイルパスを書き込みモードとしてオープンして]、fとする	f = open(filepath, mode='w')
二つのデータフレームを横方向にマージする	pd.merge(df, df2)
折れ線グラフを描画して、色をコーンズシルクに設定する	plt.plot(データ列, データ列2, color='cornsilk')
下三角マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='v')
＜オプション＞色をダークグリーンに設定する	color = 'darkgreen'
折れ線グラフに大きさnの三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markersize=n)
＜オプション＞グラフの色をドジャーブルーに変更する	color = 'dodgerblue'
再帰の上限	sys.getrecursionlimit()
日付時刻データにn日分、加算する	aDatetime + datetime.timedelta(days=n)
タプルに辞書の項目を更新する	aDict.update(aDict2)
ダークカーキ色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkkhaki')
リストとリストを用いて色差別ないグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
xを論理値に変換する	bool(x)
データ列のタイムゾーンを東京に指定する	ds.tz_convert('Asia/Tokyo')
データフレームを表示するとき折り返しをオフに指定する	pd.set_option('expand_frame_repr', False)
リストとデータ列について破線グラフを描画し、、その色を淡いに指定する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
イテラブルのコンビネーション	itertools.combinations(iterable, n)
等間隔でn個にデータフレームの中の列を分割して、namesのラベルをつける	pd.cut(df[col], n, labels=names)
文字列中のパターンを新しい文字列で置換する	re.sub(pattern, newsub, s)
文字列が漢字かどうか調べる	('\u4E00' <= ch <= '\u9FD0')
リストとリストについて破線を描いて、その色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
TSV形式のファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
リストにリストを展開する	aList.extend(aList2)
ファイルから拡張子なしのファイル名を求める	os.path.splitext(os.path.basename(filepath))[0]
文字列から日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
リストとデータ列の折れ線グラフを描画して、色を文字列に設定する	plt.plot(xdata, ydata, color=s)
暗い色のマーカーとして散布図を重なりを見やすく描く	plt.plot(xdata, ydata, c='dark', alpha=0.5)
nまでの奇整数列を作る	list(range(1, n, 2))
リストとリストについての散布図に黒い星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='k')
異なる列をキーとして二つのデータフレームを結合する	pd.merge(df, df2, left_on='A', right_on='B')
文字列のの開始位置から終了位置までの間に部分文字列がいくつか存在するか調べる	s.count(sub, start, end)
ヒストグラムを描画して、色をダークオリーブグリーンに指定する	plt.hist(データ列, color='darkolivegreen')
＜オプション＞濃いシアン色を使う	color = 'darkcyan'
日付時刻データの時刻	aDatetime.time()
２つのデータフレームを結合する	pd.merge(df, df2)
データフレームのカラムが何月か見る	df[col].dt.month
ヒストグラムを描画して、その色をネイビーに指定する	plt.hist(データ列, color='navy')
＜オプション＞四角マーカーを描画する	marker = 's'
タイムスタンプデータをISO形式の文字列にする	aDatetime.isoformat()
淡い色のマーカーで散布図を重なりを見やすく描く	plt.plot(xdata, ydata, c='muted', alpha=0.5)
既存のファイルをEUCで追加できるようにオープンする]	open(filepath, mode='a', encoding='euc_jp')
二つのオブジェクトが等しいか調べる	obj == obj2
プロットを論文用に設定する	sns.set(context='paper')
淡いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color='r')
日付データが木曜日	aDate.weekday() == 3
データフレームを二つの列によって昇順に破壊的にソートする	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
データフレームの列の値がxの行を抽出する	df[df[column] == x]
データフレームのNaNをモードで置換する	df.fillna(df.mode().iloc[0])
日付時刻データが何分か知る	aDatetime.minute
整数nの八進文字列	oct(n)[2:]
文字列は全て数値か調べる	s.isnumeric()
データフレームのリストカラムの平均値を求める	df[aList].mean()
ダークシアン色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkcyan')
整数nの十六進リテラル	hex(n)
＜オプション＞色をゴールデンロッドに設定する	color = 'goldenrod'
データフレームをタブ区切りでJSONLファイルに書き込む	df.to_csv(filename, sep='\t')
＜オプション＞ダークサーモン色を使う	color = 'darksalmon'
ヒストグラムを描画して、その色をミディアムパープルに指定する	plt.hist(データ列, color='mediumpurple')
折れ線グラフに星印を使う	plt.plot(データ列, データ列2, marker='*')
ヒストグラムの色をピンクに変更する	plt.hist(データ列, color='pink')
formatパターンの文字列を日付時刻に変換する	datetime.datetime.strptime(日付の書かれた文字列, format)
散布図に左三角マーカーを使う	plt.plot(xdata, ydata, marker='<')
暗いの色を黒くする	plt.plot(xdata, ydata, linestyle='dark', color='k')
ファイル名がCSVファイルか調べる	filename.endswith('.csv')
表データのカテゴリデータをダミー変数にする	pd.get_dummies(df)
配列を列方向に連結する	np.concatenate([aArray, aArray2], axis=0)
集合をイミュータブルなセットに変換する	frozenset(aSet)
文字列の接尾辞が部分文字列か調べる	s.endswith(sub)
三角マーカーを散布図に用いる	plt.plot(xdata, ydata, marker='^')
平均値でデータフレームのリスト列の欠損値を埋める	df[aList].fillna(df[aList].mean())
文字列を黄色で出力する	print(f'\033[33m{value}\033[0m')
＜オプション＞色をピンクに設定する	color = 'pink'
リストとリストについての散布図に黒い丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c='k')
リストの中の最大値を計算する	max(aList)
文字列をトリムする	s.strip()
折れ線グラフのバツマーカーを黄色くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='y')
リストとリストについての散布図を色差別ない色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
＜オプション＞グラフの種類を一点鎖線に設定する	linestyle = 'dashbot'
整数最小公倍数を求める	math.lcm(n, n2)
データフレームを各列毎に集約して、列の最大値を求める	df.groupby(column)[column2].max()
グラフのカラーパレットをpalleteNameに設定する	sns.set(pallete=palleteName)
折れ線グラフの色をライトシアンにセットする	plt.plot(データ列, データ列2, color='lightcyan')
線グラフを描画して、その色を真紅に指定する	plt.plot(データ列, データ列2, color='crimson')
文字列TSVファイルからCSVをn番目の列をインデックスとして読む	pd.read_csv(filename, index_col=n)
文字列をASCII限定として正規表現で分割する	re.split(pattern, s, flags=re.ASCI)
文字列が小文字か	s.islower()
データ列が何日か確認する	ds.dt.day
リストとリストについての散布図に黒いバツマーカーを描画する	plt.plot(xdata, ydata, marker='x', c='k')
nを切り捨てながら半分にする	n //= 2
データフレームを列を用いてによって大きい順に並べる	df.sort_values(by=column, ascending=False)
破線グラフの色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
データフレームのデータ型の一覧	df.dtypes
nがn2以下かどうか	n <= n2
＜オプション＞青緑に色を設定する	color = 'teal'
＜オプション＞スプリンググリーン色を使う	color = 'springgreen'
＜オプション＞紺色を使う	color = 'darkblue'
Pandasで、UNIX秒のデータ列からdatetime64型に変換する	pd.to_datetime(ds, unit='s', utc=True)
＜オプション＞ロイヤルブルー色を使う	color = 'royalblue'
xのハッシュ値を求める	hash(x)
変数について数式をn階微分する	sympy.diff(e, z, n)
折れ線グラフを描画して、その色をダークシアグリーンに設定する	plt.plot(データ列, データ列2, color='darkseagreen')
nとn2の商を計算する	n / n2
＜オプション＞ミントクリーム色を使う	color = 'mintcream'
ヒストグラムを描画して、その色をローングリーンに設定する	plt.hist(データ列, color='lawngreen')
文字列全体を大文字・小文字を無視して正規表現にマッチさせる	re.fullmatch(pattern, s, flags=re.IGNORECASE)
文字列が平仮名か調べる	('ぁ' <= ch <= 'ん')
折れ線グラフの色をミディアムパープルに設定する	plt.plot(データ列, データ列2, color='mediumpurple')
折れ線グラフの色をダークカーキに設定する	plt.plot(データ列, データ列2, color='darkkhaki')
日付時刻データが土曜日か調べる	aDatetime.weekday() == 5
配列と配列の散布図を大きさnで描く	plt.scatter(xdata, ydata, s=n)
＜オプション＞グラフの色をライトグリーンに変更する	color = 'lightseagreen'
データフレームのそれぞれのグループごとの標準偏差	df.groupby(column).std()
イテラブルにイテラブルを続けたイテラブル	itertools.chain(iterable, iterable2)
ふたつのリストの積集合を求める	list(set(aList) & set(aList2))
データフレームを関数によってまとめた表	df.groupby(関数)
＜オプション＞ミディアムシアグリーン色を用いる	color = 'mediumseagreen'
カウンタの項目一覧	aCounter.keys()
散布図をパステル調の色で描く	plt.plot(xdata, ydata, c='pastel')
日付時刻データと日付時刻データの時間差は何分か知る	(aDatetime - aDatetime2).total_seconds()//60
折れ線グラフの三角マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
データフレームから列を一つ選択する	df[[column]]
辞書から最後の項目をポップする	aDict.popitem()
明るい色の折れ線グラフを描画し、、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
＜オプション＞グラフの色をドジャーブルーに設定する	color = 'dodgerblue'
折れ線グラフの色をダークオリーブグリーンに設定する	plt.plot(データ列, データ列2, color='darkolivegreen')
散布図にカラーコードの四角マーカーを使う	plt.plot(xdata, ydata, marker='s', c=rgb)
二つの文字列は同じか調べる	s == s2
青い折れ線グラフを描画する	plt.plot(データ列, データ列2, color='b')
赤色の丸マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='o', c='r')
リストとリストについての散布図に右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>')
折れ線グラフの色をグレーに設定する	plt.plot(データ列, データ列2, color='gray')
淡いの折れ線グラフの色を赤にする	plt.plot(xdata, ydata, linestyle='muted', color='r')
文字列は片仮名	('ァ' <= ch <= 'ン')
リストとデータ列についてパステル調の色の折れ線グラフを描画して、その線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
数列とリストの散布図をプロットし、、色をパステル調のにセットする	plt.plot(xdata, ydata, c='pastel')
データ列はどの程度分散しているか調べる	ds.var()
文字列中に部分文字列が含まれないか調べる	sub not in s
横棒グラフを描画する	plt.barh(ラベル列, データ列)
線グラフを描画して、その色をダークターコイズに設定する	plt.plot(データ列, データ列2, color='darkturquoise')
カデットブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='cadetblue')
リストと配列の折れ線グラフをuntitledとラベル付けして描く	plt.plot(xdata, ydata, label=untitled)
日付時刻データが火曜日	aDatetime.weekday() == 1
折れ線グラフを描画してその色を白にする	plt.plot(データ列, データ列2, color='white')
集合をタプルに変換する	tuple(aSet)
ヒストグラムの色をパパイヤウィップに設定する	plt.hist(データ列, color='papayawhip')
赤い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='r')
プロットに凡例を入れる	plt.legend()
オブジェクトがリストかタプル	isinstance(obj, (list)
＜オプション＞オレンジを使用する	color = 'orange'
散布図を淡い色で描画する	plt.plot(xdata, ydata, c='muted')
異なる列をキーとして二つのデータフレームを外部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
折れ線グラフを描画して、その色をバリーウッドに設定する	plt.plot(データ列, データ列2, color='burlywood')
データ列を千の位で四捨五入して、整数にする	ds.round(-3).astype(int)
データフレームからカテゴリデータの列名の一覧を求める	df.select_dtypes('object').columns
文字列を部分文字列で区切り、、文字列リストに変換する	s.split(sub)
文字列リストにイテラブルを変換して、'改行で一つにする	'\n'.join(map(str, iterable))
ヒストグラムを描画して、その色を暗い赤に設定する	plt.hist(データ列, color='darkred')
日付データからn秒分、減算する	aDate - datetime.timedelta(seconds=n)
小数点数のハイパボリック・タンジェントの逆数	math.atanh(x)
日付時刻データは何秒か知る	aDatetime.second
オプションで、標準エラーを用いる	file = sys.stderr
＜オプション＞グラフの色をスカイブルーに設定する	color = 'skyblue'
折れ線グラフの印を三角印にする	plt.plot(データ列, データ列2, marker='^')
折れ線グラフの下三角マーカーを緑色にする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='g')
リストとリストについての散布図に黒い三角マーカーを描く	plt.plot(xdata, ydata, marker='^', c='k')
要素をキューの末尾に付け加える	deq.append(element)
ダークグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkgreen')
データフレームの列のユニークな値	df[col].unique()
ヒストグラムの色をミスティローズに指定する	plt.hist(データ列, color='mistyrose')
データフレームの指定されたデータ型の列名を列挙する	df.select_dtypes(型).columns
データフレームをJSONLファイルにBOM付きで保存する	df.to_csv(filename, encoding='utf_8_sig')
データフレームの中で、列に重複があるか見る	df.duplicated(subset=column)
データフレームの中の列を等量で分割数nでビン分割する	pd.qcut(df[col], n)
データフレームの列の名前の一覧を使う	df.columns
CSVファイルからデータフレームを読む	pd.read_csv(filename, sep=',')
文字列を新しい文字列で置き換える	s.replace(sub, newsub)
＜オプション＞アリスブルー色を使う	color = 'aliceblue'
線グラフを描画して、その色をミディアムターコイズに設定する	plt.plot(データ列, データ列2, color='mediumturquoise')
＜オプション＞エンコーディングをEUCに設定する	encoding = 'euc_jp'
データ列のタイムゾーンを日本に設定する	ds.tz_convert('Asia/Tokyo')
＜オプション＞ロイヤルブルーにグラフの色を変更する	color = 'royalblue'
符号なしでnをバイト列に変換する	n.to_bytes(length=bytesize, byteorder='big')
＜オプション＞マゼンタ色を使う	color = 'magenta'
ヒストグラムを描画してその色をインディゴに設定する	plt.hist(データ列, color='indigo')
実行時の標準出力の出力先がターミナルかどうか確認する	sys.stdout.isatty()
折れ線グラフの色をラベンダーに設定する	plt.plot(データ列, データ列2, color='lavender')
配列とリストについてカラーコードの濃いを描画する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
数式を簡単にする	sympy.sympify(e)
データフレームの中にいくつ欠損値が存在するか数える	df.isna().sum()
折れ線グラフを描画して、その色をアリスブルーに設定する	plt.plot(データ列, データ列2, color='aliceblue')
組を引数として展開してプリントする	print(*aTuple, sep=',')
ヒストグラムを描画して、その色を茶色に設定する	plt.hist(データ列, color='brown')
折れ線グラフに緑色の右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='g')
2つの変数をコロンで区切ってプリントする	print(value, value2, sep=':')
データフレームから重複するデータを残さず、削除する	df.drop_duplicates(keep=False)
赤い右三角マーカーを数列と配列の散布図に描く	plt.plot(xdata, ydata, marker='>', c='r')
ヒストグラムを描画してその色をミッドナイトブルーに設定する	plt.hist(データ列, color='midnightblue')
データフレームをグループ化し、それぞれの列に対し平均値を求める	df.groupby(column)[column2].mean()
コーンズシルク色のヒストグラムを描画する	plt.hist(データ列, color='cornsilk')
行列の行ごとの分散を算出する	np.var(aArray, axis=1)
カンマ区切りのファイルからデータフレームを読み込む	pd.read_csv(filename, sep=',')
リストをn個にビン分割して、namesのラベルをつける	pd.cut(aList, n, labels=names)
ヒストグラムの色をペールグリーンに設定する	plt.hist(データ列, color='palegreen')
文字列リストを連結する	''.join(aStringList)
計算機イプシロン	sys.float_info.epsilon
マッピングのコピーを作成する	dict(aDict)
二つの集合が集合と互いに素	aSet.isdisjoint(aSet2)
＜オプション＞グラフの色をチョコレートに設定する	color = 'chocolate'
カラーコードの大バツマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='X', c=rgb)
データフレームの列の文字列で文字列が含まれない行を選択する	df[not df[column].str.contains(s)]
線グラフを描画して色をナバホホワイトにセットする	plt.plot(データ列, データ列2, color='navajowhite')
線グラフの色をフローラルホワイトに設定する	plt.plot(データ列, データ列2, color='floralwhite')
折れ線グラフの色を黄色くする	plt.plot(データ列, データ列2, color='y')
折れ線グラフを描画して、その色をミディアムスレートブルーに設定する	plt.plot(データ列, データ列2, color='mediumslateblue')
ヒストグラムをstartからendまでの範囲で描く	plt.hist(データ列, range=(start, end))
ヒストグラムを描画して、その色をライトグリーンに指定する	plt.hist(データ列, color='lightseagreen')
データ列の中に文字列と文字列があるか調べる	ds.isin([value, value2])
最初のカテゴリーを除外し、データフレームの列をダミー変数にする	pd.get_dummies(df[column], drop_first=True)
ヒストグラムを描画して、その色をグレーに変更する	plt.hist(データ列, color='gray')
文字列中にひとつでも非数字が含まれるか調べる	any(not c.isdigit() for c in s)
イテラブルを文字列リストに変換して、'改行で連結する	'\n'.join(map(str, iterable))
行列の転置行列	aArray.T
日付時刻データが水曜日	aDatetime.weekday() == 2
二進数文字列をバイト列にする	int(s, 2).to_bytes(length=bytesize, byteorder='big')
辞書をコピーする	dict(aDict)
文字列を文字コード列に変換する	[ord(ch) for ch in s]
文字列を特殊文字も含め小文字にする	s.casefold()
折れ線グラフにサイズnの四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markersize=n)
折れ線グラフを描画して、その色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
散布図に黒い下三角マーカーを使う	plt.plot(xdata, ydata, marker='v', c='k')
濃いの折れ線グラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
折れ線グラフに黒い星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='k')
散布図にカラーコードの星マーカーを使う	plt.plot(xdata, ydata, marker='*', c=rgb)
ヒストグラムを描画して、その色をダークオーキッドに設定する	plt.hist(データ列, color='darkorchid')
日付データが水曜日か調べる	aDate.weekday() == 2
＜オプション＞追加モードを使う	mode = 'a'
nを8進表現に変換する	oct(n)
オブジェクトは整数クラスか調べる	isinstance(obj, int)
データフレームの列がx以上の行を抽出する	df[df[column] >= x]
文字列の無限イテラブル	itertools.repeat(element)
折れ線グラフを描く	plt.plot(xdata, ydata)
データフレームを列の値によってグループ化して、列挙する	[(name, group) for name, group in df.groupby(column)]
データ列を10の位で丸める	ds.round(-1)
リストとリストの散布図にカラーコードのクロスマーカーを描画する	plt.plot(xdata, ydata, marker='x', c=rgb)
ファイルをSJISで追加できるようにオープンする]	open(filepath, mode='a', encoding='shift_jis')
ヒストグラムの色をディープスカイブルーに設定する	plt.hist(データ列, color='deepskyblue')
両端キューの先頭に要素を追加する	deq.appendleft(element)
xの小数点以下'1'桁までを表示する	print(':.1f'.format(x))
パラメータについて数値を積分する	sympy.integrate(e, z)
データフレームのリストカラムの第三四分位数	df[aList].quantile(0.75)
日付データにn秒分加算する	aDate + datetime.timedelta(seconds=n)
暗い色として重なりを見やすく散布図を描画する	plt.plot(xdata, ydata, c='dark', alpha=0.5)
折れ線グラフの大バツマーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='X', markeredgewidth=n)
折れ線グラフを描画して、その色をダークゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='darkgoldenrod')
文字列がリストの要素でない	element not in aList
Pythonパスのリストを知る	sys.path
＜オプション＞ブール型を使う	dtype = np.int32
＜オプション＞フォレストグリーン色を使う	color = 'forestgreen'
ゼロ埋めされた三二ビット整数型の配列	np.zeros(要素数, dtype=np.int16)
日付時刻データと日付時刻データの時間差を秒数で求める	(aDatetime - aDatetime2).total_seconds()//60
カラーコードの丸マーカーを散布図に使う	plt.plot(xdata, ydata, marker='o', c=rgb)
日付データが火曜日か調べる	aDate.weekday() == 1
線グラフを描画して、その色をダークゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='darkgoldenrod')
リストを文字列リストに変換して空白を用いて連結する	' '.join(map(str, iterable))
＜オプション＞グラフの色をイエローグリーンにセットする	color = 'yellowgreen'
列の長さnの順列	itertools.permutations(iterable, n)
折れ線グラフの色をビスクに変更する	plt.plot(データ列, データ列2, color='bisque')
整数nのビット長	n.bit_length()
＜オプション＞グラフの色をダークオーキッドに設定する	color = 'darkorchid'
折れ線グラフの色をグリーンイエローに設定する	plt.plot(データ列, データ列2, color='greenyellow')
ヒストグラムの色をパパイヤウィップに指定する	plt.hist(データ列, color='papayawhip')
イテラブルと配列について散布図を描画して、その大きさをnに設定する	plt.scatter(xdata, ydata, s=n)
イテラブルを累加する	itertools.accumulate(iterable)
ファイルパスを読み込みモードでオープンして]fとする	f = open(filepath, mode='r')
セットが空でないかどうか	len(aSet) != 0
アクア色のヒストグラムを描画する	plt.hist(データ列, color='aqua')
本日が月曜日か調べる	datetime.datetime.today().weekday() == 0
配列と数列について散布図を描画してマーカーの色を暗いに変更する	plt.plot(xdata, ydata, c='dark')
パターンに文字列全体をマッチさせる	re.fullmatch(pattern, s)
部分文字列が文字列中に含まれるか調べる	sub in s
実数の三乗	x ** 3
折れ線グラフを描画して、色をレモンシフォンに設定する	plt.plot(データ列, データ列2, color='lemonchiffon')
aListn番目から要素を取り出す	aList.pop(n)
データフレームのカラムの要約統計量	df[col].describe()
ヒストグラムを描画して、その色をオリーブに設定する	plt.hist(データ列, color='olive')
カウンタの最頻出な項目	aCounter.most_common()[0]
データ列とリストについてパステル調のグラフをプロットしてその色を黒にする	plt.plot(xdata, ydata, linestyle='pastel', color='k')
数字が文字列内に含まれるか調べる	any(c.isdigit() for c in s)
データフレームを列でソートする	df.sort_values(by=column)
ナバホホワイト色のヒストグラムを描画する	plt.hist(データ列, color='navajowhite')
＜オプション＞文字コードをSJISに設定する	encoding = 'shift_jis'
データフレームの列が文字列で終わる行を抽出する	df[df[column].str.endswith(s)]
データフレームを100の位で丸めて整数型にする	df.round(-2).astype(int)
折れ線グラフを描画してその色を耐火レンガに設定する	plt.plot(データ列, データ列2, color='firebrick')
紺にヒストグラムの色を設定する	plt.hist(データ列, color='darkblue')
文字列中にひとつでも非アスキー文字が含まれるか	any(not c.isascii() for c in s)
赤い折れ線グラフを描画する	plt.plot(データ列, データ列2, color='r')
データフレームの列をValueMapでまとめて置き換える	df[col].replace(ValueMap)
二つのデータフレームを縦方向につなぐ	pd.concat([df, df2], axis=0)
文字列を最後の部分文字列で二つに分ける	s.rpartition(sub)
折れ線グラフを描画して、その色をネイビーに設定する	plt.plot(データ列, データ列2, color='navy')
nが一桁の数か調べる	0 <= n <= 9
＜オプション＞ホワイトスモーク色を使う	color = 'whitesmoke'
日付データが何日か知る	aDate.day
配列の行ごとの合計値	np.sum(aArray, axis=1)
文字列の両端から部分文字列を除く	s.strip(sub)
データフレームのカラムの中央値	df[col].median()
データフレームのリストカラムの第二四分位数	df[aList].median()
文字列内にアルファベットが含まれる	any(c.isalpha() for c in s)
データフレームのカラムの欠損値を最小値に設定する	df[col].fillna(df[col].min())
赤色の丸マーカーとして散布図をプロットする	plt.plot(xdata, ydata, marker='o', c='r')
＜オプション＞グラフの色をネイビーに設定する	color = 'navy'
データフレームを表示するときヘッダー行を右寄せにセットする	pd.set_option('colheader_justify', 'right')
文字列の開始位置からと終了位置の間に部分文字列が含まれるか調べる	s.find(sub, start, end) != -1
＜オプション＞ミディアムスレートブルー色を使う	color = 'mediumslateblue'
折れ線グラフを描画して、その色を淡いピンク色に設定する	plt.plot(データ列, データ列2, color='lightpink')
マッピングをJSON形式でファイル出力に保存する	json.dump(aDict, fout, ensure_ascii=False)
商と余りを同時に計算する	divmod(x, y)
行列のユニークな要素とその個数を求める	u, counts = np.unique(aArray, return_counts=True)
青い明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color='b')
リストとリストとして明るいの折れ線を描き、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color='r')
リストとリストの黒いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='k')
リストとリストについての散布図を暗い色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='dark', alpha=0.5)
nがn2以上か調べる	n >= n2
箱髭図としてデータ列を可視化する	plt.boxplot(データ列)
折れ線グラフの色をブラックに設定する	plt.plot(データ列, データ列2, color='black')
データフレームのリストカラムを100の位で丸めて、整数型にする	df[aList].round(-2).astype(int)
リストとリストについて色差別ない色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='colorblind')
データフレームのカラムを1000の位で丸めて整数型にする	df[col].round(-3).astype(int)
正規表現モジュールをインポートする	import re
データフレームを各列毎に集約して、列の最小値を求める	df.groupby(column)[column2].min()
日付時刻データが日付時刻データより先か調べる	aDatetime < aDatetime2
n進文字列を整数に変換する	int(s, n)
折れ線グラフを描画してその色をクリムゾンに指定する	plt.plot(データ列, データ列2, color='crimson')
辞書をJSON形式でファイル出力に保存する	json.dump(aDict, fout, ensure_ascii=False)
等差数列を配列に変換する	np.arange(開始値, 終端値, 等差)
淡いピンク色色のヒストグラムを描画する	plt.hist(データ列, color='lightpink')
折れ線グラフを描画して、その色を赤に設定する	plt.plot(データ列, データ列2, color='red')
パステル調の色をグラフの描画で用いる	sns.set(pallete='pastel')
n個の集まりからk個重複なく選ぶ方法	math.comb(n, k)
replにデータフレームのリスト列を正規表現patternで置き換える	df[aList].replace(pattern, repl, regex=True)
nがn2よりも小さいか調べる	n < n2
折れ線グラフのポイントマーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='.', markersize=n)
赤色のポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.', c='r')
エクセルファイルファイルからn番目のシートをデータフレームとして読む	pd.read_excel(filename, sheet_name=n)
リストと配列についての散布図に赤い左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c='r')
文字列の変数名を数式に変換する	sympy.Symbol(s)
データフレームの欠損値が含まれる部分に色を付ける	df.style.highlight_null()
リストとリストでパステル調のの折れ線を描画してその線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
文字列全体をパターンに複数行対応としてマッチさせる	re.fullmatch(pattern, s, flags=re.MULTILINE)
辞書から計数器を準備する	collections.Counter(aDict)
折れ線グラフを描画して色を青に設定する	plt.plot(データ列, データ列2, color='blue')
データフレームを複数の列によってソートする	df.sort_values(by=column)
データフレームのリストカラムの値をValueMapでまとめて置き換える	df[aList].replace(ValueMap)
文字列をシンボルに変換する	sympy.Symbol(s)
マッピングをコピーする	aDict.copy()
データフレームのリストカラムを10の位で四捨五入して、整数型にする	df[aList].round(-1).astype(int)
本日を文字列でフォーマットして文字列に変換する	"datetime.datetime.today().strftime(""%d/%m/%y"")"
xの小数点以下'5'桁までプリントする	print(':.5f'.format(x))
折れ線グラフを描画してその色をミディアムアクアマリンに設定する	plt.plot(データ列, データ列2, color='mediumaquamarine')
ダークゴールデンロッド色のヒストグラムを描画する	plt.hist(データ列, color='darkgoldenrod')
ミッドナイトブルー色のヒストグラムを描画する	plt.hist(データ列, color='midnightblue')
色差別ないパレットをグラフの描画で使う	sns.set(pallete='colorblind')
データフレームのリストカラムの母標準偏差	df[aList].std(ddof=0)
データフレームの列がリストに含まれる行を抽出する	df[df[column].isin(aList)]
ヒストグラムを描画してその色をミディアムオーキッドに設定する	plt.hist(データ列, color='mediumorchid')
データフレームの中にいくつ文字列があるか数える	df.isin([value]).sum()
xの小数点以下'1'桁までの文字列にする	':.1f'.format(x)
イテラブルを集合に変換する	set(iterable)
ヒストグラムを描画して、その色をロージーブラウンに設定する	plt.hist(データ列, color='rosybrown')
行列の列ごとの最小値を計算する	np.min(aArray, axis=0)
折れ線グラフの色をペールグリーンに設定する	plt.plot(データ列, データ列2, color='palegreen')
年月日と時刻からタイムスタンプ	datetime.datetime(年, 月, 日, 時, 分, 秒)
黄色いヒストグラムを描画する	plt.hist(データ列, color='y')
配列の差	aArray - aArray2
折れ線グラフの下三角マーカーのサイズをnに変更する	plt.plot(データ列, データ列2, marker='v', markersize=n)
日付データが土曜日か	aDate.weekday() == 5
濃い色でリストについてのヒストグラムを描く	plt.hist(xdata, color='deep')
正規化されたヒストグラムを描く	plt.hist(データ列, density=True)
データ列の数値時刻から日付データにする	pd.to_datetime(ds, unit='s', utc=True)
文字列の最後から範囲を指定して部分文字列を探す	s.find(sub, start, end)
線グラフを描画して、その色をブラックにする	plt.plot(データ列, データ列2, color='black')
＜オプション＞ゲインズボロ色を使う	color = 'gainsboro'
平均でデータフレームのリストカラムの欠損値を埋める	df[aList].fillna(df[aList].mean())
データフレームの列の中にある文字列と文字列の合計をカウントする	df[col].isin([value, value2]).sum()
日付データからn日分、減算する	aDate - datetime.timedelta(days=n)
折れ線グラフの色をライトグレーに設定する	plt.plot(データ列, データ列2, color='lightgrey')
散布図に▲マーカーを使う	plt.plot(xdata, ydata, marker='^')
nをn2乗に増やす	n **= n2
データフレームのリストカラムの欠損値をメディアンに設定する	df[aList].fillna(df[aList].median())
データフレームから重複した行をドロップして、更新する	df.drop_duplicates(inplace=True)
＜オプション＞シルバー色を使用する	color = 'silver'
折れ線グラフに大きさnの大バツ印を描画する	plt.plot(データ列, データ列2, marker='X', markersize=n)
データフレームから数値データの列を抽出する	df.select_dtypes('number')
ヒストグラムでデータフレームの列を可視化する	plt.hist(df[column])
双方向キューの最初の要素	deq[0]
文字列を走査し、正規表現にマッチするか見る	re.search(pattern, s)
リストの個数だけ繰り返す	range(len(aList))
文字列が全て英数字か調べる	s.isalnum()
小数点数のサインの逆数	math.asin(x)
文字列を改行で分割し、文字列リストにする	s.splitlines()
JSONを使う	import json
Pandasでデータフレームのカラムをインデックスにする	df.set_index(col, inplace=True)
システム時刻で乱数を初期化する	random.seed()
Pandasで日付データのデータフレームのカラムをインデックスにする	df.index = pd.DatetimeIndex(df[col])
ヒストグラムを描画して、色をミッドナイトブルーに指定する	plt.hist(データ列, color='midnightblue')
文字列を複数行対応としてパターンで分割する	re.split(pattern, s, flags=re.MULTILINE)
折れ線グラフの星マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='*', markersize=n)
折れ線グラフの色をスラグレーにセットする	plt.plot(データ列, データ列2, color='slategray')
データフレームをCSVから読み込む	pd.read_csv(filename, sep=',')
二つのカウンタの共通する要素を求める	aCounter & aCounter2
データフレームを複数の列によってまとめたグループ	df.groupby(columns)
データフレームの先頭n行	df.head(n)
中央値でデータ列を分割する	pd.qcut(ds, 2)
xの小数点以下'3'桁までをプリントする	print(':.3f'.format(x))
折れ線グラフの色をレベッカパープルに変更する	plt.plot(データ列, データ列2, color='rebeccapurple')
'A'列と'B'列でによって大きい順にデータフレームを並べ直す	df.sort_values(by=['A', 'B'], ascending=False)
＜オプション＞ライトグレー色を使う	color = 'lightgray'
データフレームのリストカラムの欠損値を最小値に設定する	df[aList].fillna(df[aList].min())
＜オプション＞シーグリーン色を使う	color = 'seagreen'
タイムスタンプデータは何曜日か知る	aDatetime.weekday()
ヒストグラムを描画して、その色をラベンダーに設定する	plt.hist(データ列, color='lavender')
リストとリストについて淡い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
＜オプション＞ミディアムパープル色を使う	color = 'mediumpurple'
にx=0の一点鎖線を付ける	plt.axvline(x=0, linestyle='dashbot')
ヒストグラムを描画して、その色をスカイブルーに指定する	plt.hist(データ列, color='skyblue')
複数の列の値によってデータフレームをまとめた表	df.groupby(columns)
折れ線グラフの色をダークバイオレットに設定する	plt.plot(データ列, データ列2, color='darkviolet')
ヒストグラムの線のスタイルを点線に設定する	plt.hist(データ列, linestyle='dotted')
データ列と配列の青い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='b')
折れ線グラフを描画して、色を黒くする	plt.plot(データ列, データ列2, color='k')
文字列を回数を制限して置き換える	s.replace(sub, newsub, n)
データ列の欠損値を直前の値に設定する	ds.fillna(method='ffill')
データフレームの欠損値を最頻値に設定する	df.fillna(df.mode().iloc[0])
2つの変数を同じ値にする	x = y = n
ヒストグラムを描画して、ビン数をnに設定する	plt.hist(データ列, bins=n)
データフレームをインデックスによって降順でソートする	df.sort_index(ascending=False)
文字列の平仮名を片仮名に変換する	''.join([chr(ord(ch) + 96) if ('ぁ' <= ch <= 'ん') else ch for ch in s])
＜オプション＞グラフの色をライトイエローに指定する	color = 'lightyellow'
データフレームのどの値が頻出か確認する	df.mode()
整数の最大公約数を求める	math.gcd(n, n2)
柱状図をstartからendまでの範囲で描画する	plt.hist(データ列, range=(start, end))
CSVファイルTSVファイルをn番目のカラムをインデックスとして読み込む	pd.read_csv(filename, index_col=n)
辞書のキーと値を入れ替える	{v: k for k, v in aDict.items()}
データフレームを列によってグループ分けして、各グループの最小値を算出する	df.groupby(column).min()
データフレームから1行だけカラムを消す	pd.concat([df[df.columns[:n]], df[df.columns[n+1:]]], axis=1)
＜オプション＞グラフの色をロージーブラウンに設定する	color = 'rosybrown'
折れ線グラフの印を右三角にする	plt.plot(データ列, データ列2, marker='>')
データフレームのリストカラムを100の位で丸めて、整数にする	df[aList].round(-2).astype(int)
ヒストグラムをカラーマップを使って描画する	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
データフレームの内のNaNがある行を削除する	df.dropna()
ヒストグラムを描画して、その色をライトグリーンに設定する	plt.hist(データ列, color='lightgreen')
折れ線グラフに黒いバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='k')
ヒストグラムを描画してその色をペールグリーンに設定する	plt.hist(データ列, color='palegreen')
折れ線グラフの透明度をalphaに設定する	plt.plot(xdata, ydata, alpha=alpha)
折れ線グラフの大バツマーカーを赤くする	plt.plot(データ列, データ列2, marker='X', markerfacecolor='r')
リストとリストでパステル調のグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
データフレームのn行以降取り出す	df[n:]
二つの文字列は等しい	s == s2
配列と配列について散布図を描画し、、左三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='<', c=rgb)
データ列の時を使う	ds.dt.hour
文字列リストを結合してひとつの文字列にする	''.join(map(str, iterable))
リストとリストについて散布図を描画して、大バツマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='X', c=rgb)
ファイルから読み込みストリームをオープンして]、fとする	f = open(filepath, mode='r')
データフレームを'A'列によってによって破壊的にソートする	df.sort_values(by='A', inplace=True)
ヒストグラムを描画して、その色をダークスラテグレーに変更する	plt.hist(データ列, color='darkslategray')
空列	[]
データフレームの列がx以下の行を抽出する	df[df[column] <= x]
nがn2と等しいかどうか調べる	n == n2
リストの先頭を除く	aList[1:]
ヒストグラムを描画して、半透明ににする	plt.hist(データ列, alpha=0.5)
データフレームを列の値でグループ化して、合計を求める	df.groupby(column).sum()
ヒストグラムを描画して、その色をライトスレイグレーにする	plt.hist(データ列, color='lightslategray')
散布図に赤色の下三角マーカーを使う	plt.plot(xdata, ydata, marker='v', c='r')
nが3の倍数か確認する	n % 3 == 0
ヒストグラムを描画して、色をグリーンに設定する	plt.hist(データ列, color='green')
折れ線グラフの星マーカーを青くする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='b')
日付データが日付データより前か調べる	aDate < aDate2
データフレームからカテゴリデータの列名の一覧を使う	df.select_dtypes('object').columns
タプルの最初の文字列を探す	aTuple.index(element)
リストとリストについての散布図に赤い下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v', c='r')
折れ線グラフの色を赤に指定する	plt.plot(データ列, データ列2, color='red')
文字列は印字できるか確認する	s.isprintable()
文字列の中の複数行対応としてパターンによる全てのマッチを使う	re.findall(pattern, s, flags=re.MULTILINE)
黒いダイアモンドマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='D', c='k')
要素がマップの値に含まれていない	element not in aDict.values()
＜オプション＞ディープスカイブルーに色を変更する	color = 'deepskyblue'
カラムの中の欠損値の合計を数える	ds.isna().sum()
折れ線グラフを描画して、その色をリネンに設定する	plt.plot(データ列, データ列2, color='linen')
JSONファイルのファイル入力を読み込んで、dataとする	data = json.load(fin)
行列の各要素の最小公倍数を求める	np.lcm(aArray, aArray2)
データフレームの列の名前を付け直す	df.rename(columns={column: name})
実数の小数部	math.modf(x)[0]
ふたつの集合が集合と交わりを持たないか確認する	aSet.isdisjoint(aSet2)
折れ線グラフに黄色い三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='y')
明るいグラフの色を赤くする	plt.plot(xdata, ydata, linestyle='bright', color='r')
データフレームのリストカラムのNaNを後の行の値で埋める	df[aList].fillna(method='bfill')
オレンジレッド色のヒストグラムを描画する	plt.hist(データ列, color='orangered')
見やすいグラフを用いる準備をする	import seaborn as sns
ヒストグラムの色をダークグリーンに設定する	plt.hist(データ列, color='darkgreen')
日付データは日付データより後ろか調べる	aDate > aDate2
環境がWindows	sys.platform.startswith('win32')
数列とリストの散布図を描画し、ポイントマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='.', c=rgb)
折れ線グラフに大きさnの四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markersize=n)
＜オプション＞マーカーを三角に変更する	marker = '^'
リストとリストで暗いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', color='r')
暗い赤色のヒストグラムを描画する	plt.hist(データ列, color='darkred')
＜オプション＞オールドレース色を使う	color = 'oldlace'
＜オプション＞グラフの色をシャルトリューズに設定する	color = 'chartreuse'
文字列中にひとつでも非大文字が含まれる	any(not c.isupper() for c in s)
各列毎にデータフレームを集約して、列の平均値を求める	df.groupby(column)[column2].mean()
赤い左三角マーカーを散布図に使う	plt.plot(xdata, ydata, marker='<', c='r')
名前付きタプルを定義する	C = collections.namedtuple('クラス名', プロパティ名)
日付時刻データを文字列でフォーマットする	"aDatetime.strftime(""%d/%m/%y"")"
イテラブルを多重集合にする	collections.Counter(iterable)
折れ線グラフに赤い△マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
日付時刻データの日付を使う	aDatetime.date()
＜オプション＞グラフの色をミディアムターコイズに設定する	color = 'mediumturquoise'
プロットの色を全般的に濃くする	sns.set(pallete='deep')
カウンタを多い順に列挙する	aCounter.most_common()
＜オプション＞シートの名前をnamesに設定する	sheet_name = names
単位正方行列	np.identity(N)
散布図を濃い色のマーカーとして重なりを見やすく描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
リストの要素を逆順にする	aList[::-1]
ヒストグラムを描画して、色をライムグリーンに設定する	plt.hist(データ列, color='limegreen')
整数nが配列のどれかか調べる	n in aArray
ファイルから書き込みストリームをオープンして]、fとする	f = open(filepath, mode='w')
文字列のケースを変換する	s.casefold()
ラベンダー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lavender')
ファイルをオープンして]、バイナリ書き込みストリームを使う	open(filepath, mode='wb')
折れ線グラフにラベルを付ける	plt.plot(xdata, ydata, label=untitled)
黒いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='k')
散布図に濃い色のマーカーを用いる	plt.plot(xdata, ydata, c='deep')
データ列を折れ線グラフに描画して、印をダイアモンドにする	plt.plot(データ列, データ列2, marker='D')
折れ線グラフに線幅nの菱形マーカーを描画する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
ヒストグラムの色をレモンシフォンに変更する	plt.hist(データ列, color='lemonchiffon')
プロットを描く準備をする	from sympy import N
実数から浮動小数点数を引く	x - y
折れ線グラフを描画して、その色をミディアムターコイズに設定する	plt.plot(データ列, データ列2, color='mediumturquoise')
集合＼集合	aSet.difference(aSet2)
ヒストグラムを描画して、色をライトスレイグレーに設定する	plt.hist(データ列, color='lightslategrey')
データ列の正規分布に対する上下広がりを計算する	ds.skew()
文字列中の部分文字列の登場を数える	s.count(sub)
折れ線グラフの色をシャルトリューズに変更する	plt.plot(データ列, データ列2, color='chartreuse')
黒い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='k')
バイナリ書き込みできるようにファイルパスをオープンする]	open(filepath, mode='wb')
バイナリできるようにファイルパスをオープンする]	open(filepath, mode='rb')
文字列を最後の部分文字列で二分し、後半の文字列を見る	s.rpartition(sub)[-1]
黒色の左三角マーカーを数列とリストについての散布図に描画する	plt.plot(xdata, ydata, marker='<', c='k')
折れ線グラフの色をミディアムパープルに変更する	plt.plot(データ列, データ列2, color='mediumpurple')
リストと数列についての散布図に赤い四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c='r')
３つの数値を順に出力する	print(value, value2, value3)
＜オプション＞グラフの色をダークターコイズに変更する	color = 'darkturquoise'
散布図にカラーコードの△マーカーを用いる	plt.plot(xdata, ydata, marker='^', c=rgb)
数値を簡略化する	sympy.sympify(e)
データフレームのカラムの欠損値を直前の値に設定する	df[col].fillna(method='ffill')
データ列と配列の散布図に四角マーカーを描画する	plt.plot(xdata, ydata, marker='s')
n個の数値イテラブルを使う	range(n)
データ構造を使う	import collections
暗い色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='dark')
文字列はPythonのキーワードかどうか調べる	keyword.iskeyword(s)
リストとリストの散布図を描画して、マーカーを星に設定する	plt.plot(xdata, ydata, marker='*')
データフレームから数値データのカラムを抽出する	df.select_dtypes('number')
Pandasで、データ列のエポック秒から日付データに変換する	pd.to_datetime(ds, unit='s', utc=True)
JSONファイルのファイル入力を辞書に変換する	json.load(fin)
オブジェクトがフィールドを持つか調べる	hasattr(obj, プロパティ名)
リストとリストについて散布図を描画して、その大きさをnに設定する	plt.scatter(xdata, ydata, s=n)
事前に正規表現をコンパイルする	re.compile(pattern)
二つの集合の積集合	aSet.intersection(aSet2)
リストと配列の散布図に赤色のポイントマーカーを描く	plt.plot(xdata, ydata, marker='.', c='r')
エクセルファイルファイルからすべてのシートを読み込む	pd.read_excel(filename, sheet_name=None)
プロットの用途を論文に設定する	sns.set(context='paper')
アルファベットの小文字を全部使う	string.ascii_lowercase
本日が金曜日か調べる	datetime.datetime.today().weekday() == 4
データフレームのカラムを十の位で四捨五入する	df[col].round(-1)
文字コードtextでファイルを開く]	open(filepath, encoding=text)
本日が日曜日か調べる	datetime.datetime.today().weekday() == 6
＜オプション＞▲マーカーを加える	marker = '^'
＜オプション＞ミディアムバイオレットレッド色を使う	color = 'mediumvioletred'
配列と配列についての散布図に下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v')
nをn2だけ減少させる	n -= n2
データ列とリストの青い明るいグラフを描く	plt.plot(xdata, ydata, linestyle='bright', color='b')
タイムスタンプデータが水曜日か調べる	aDatetime.weekday() == 2
文字列内にひとつでも英数字が含まれるか調べる	any(c.isalnum() for c in s)
ミディアムブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumblue')
異なる列をキーにして二つのデータフレームを内部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
キューの中に数値がある	element in deq
整数nがセットのどれかかどうか	n in aSet
データフレームの値をValueMapでまとめて置き換える	df.replace(ValueMap)
スピアマンを用いてデータフレームのリストで指定した列の相関行列を求める	df[aList].corr(method='spearman')
カラムの欠損値を直後の値に設定する	ds.fillna(method='bfill')
折れ線グラフの色をライトサーモンに設定する	plt.plot(データ列, データ列2, color='lightsalmon')
今日が日曜日か調べる	datetime.datetime.today().weekday() == 6
ヒストグラムを描画して、その色をオレンジに変更する	plt.hist(データ列, color='orange')
データフレームを各列毎にグループ化し、、文字列というグループの個数を計算する	df.groupby(column).size()[s]
双方向キューの要素を反転する	deq.reverse()
n行までデータフレームを表示できるようにする	pd.set_option('display.max_rows', n)
二変数の最小値を求める	min(x, y)
グラフのカラーパレットをpalleteNameで指定する	sns.set(pallete=palleteName)
リストとイテラブルについて濃い色の折れ線グラフを描画して、その線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='deep')
タプルの先頭のn要素を取り除く	aTuple[n:]
データ列とリストについて散布図を描画し、、マーカーをポイントに変更する	plt.plot(xdata, ydata, marker='.')
標準出力を	sys.stdout
マッピングから項目名の値	aDict.get(key)
イテラブルの長さnの順列	itertools.permutations(iterable, n)
nが正の数か調べる	n > 0
日付時刻データをn日前に戻す	aDatetime - datetime.timedelta(days=n)
データフレームのカラムが正規分布からどれだけ、尖っているか見る	df[col].skew()
破壊的に小さい順に'A'列と'B'列によってデータフレームをソートする	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
シーケンスを文字列リストに変換してカンマで一つにする	','.join(map(str, iterable))
TSVファイルをデータフレームとして読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
リストの最後からn番目以前の部分を取り出す	aList[:-n]
実数の正弦の逆数	math.asin(x)
文字列中のタブ文字を空白に置き換える	s.expandtabs(tabsize=n)
グラフの描画で暗いカラーパレットを使う	sns.set(pallete='dark')
＜オプション＞グラフの色をハニーデューに設定する	color = 'honeydew'
折れ線グラフの下三角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='v', markersize=n)
ベクトルの要素ごとの積	np.multiply(aArray, aArray2)
文字列中にひとつでも非アルファベットが含まれる	any(not c.isalpha() for c in s)
ライトグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightgreen')
＜オプション＞グラフの色をラベンダーブラッシュに設定する	color = 'lavenderblush'
自然数個のものからk個取り出したときの並べ方の総数	math.perm(n, k)
散布図にカラーコードの三角マーカーを使う	plt.plot(xdata, ydata, marker='^', c=rgb)
データ列とリストについて淡いグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='muted', color='k')
線グラフを描画して色を黄色に設定する	plt.plot(データ列, データ列2, color='yellow')
ヒストグラムを描画して、その色をライトスチールブルーに設定する	plt.hist(データ列, color='lightsteelblue')
文字列の接頭辞が部分文字列	s.startswith(sub)
タプルの要素を逆順にする	aTuple[::-1]
文字列を空白によって区切って整数リストに変換する	map(int, s.split())
実数の天井	math.ceil(x)
配列を平坦にする	aArray.flatten()
線グラフの色をデピンクに設定する	plt.plot(データ列, データ列2, color='deeppink')
折れ線グラフの▲印の線幅をnに設定する	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
折れ線グラフの色をオレンジレッドに変更する	plt.plot(データ列, データ列2, color='orangered')
nをn2で割る	n / n2
二つのリストからマップ	dict(zip(aList, aList2))
データフレームを'A'列によってによって破壊的に並べる	df.sort_values(by='A', inplace=True)
ヒストグラムを描画して、その色をターコイズに設定する	plt.hist(データ列, color='turquoise')
折れ線グラフに青い下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
列を2回あわせた直積	itertools.product(iterable, repeat=2)
昇順に'A'列を用いてデータフレームをソートする	df.sort_values(by='A', ascending=True)
名前付きタプルをデータからインスタンス化する	C._make(パラメータ)
Pandasで日付データのデータ列をデータフレームのインデックスにする	df.index = pd.DatetimeIndex(ds)
ディレクトリをPythonパスに加える	sys.path.append(os.path.join(os.path.dirname(__file__), dir))
折れ線グラフを描画して、その色をパープルに設定する	plt.plot(データ列, データ列2, color='purple')
データフレームのカラムの欠損値を最小値に変更する	df[col].fillna(df[col].min())
＜オプション＞ナバホホワイトにグラフの色を設定する	color = 'navajowhite'
文字列を最後の部分文字列で分けたときの前半の文字列	s.rpartition(sub)[0]
折れ線グラフに黒い下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='k')
折れ線グラフを描画してその色をミディアムスレートブルーに指定する	plt.plot(データ列, データ列2, color='mediumslateblue')
＜オプション＞線幅をnに変更する	linewidth = n
データフレームを各列と列の組み合わせ毎に集計して、合計を求める	df.groupby([column, column2], as_index=False).sum()
列の全順列を求める	itertools.permutations(iterable)
文字列中の部分文字列をカウントする	s.count(sub)
データ列の未入力値を最大値で補う	ds.fillna(ds.max())
xが-9以上、9以下かどうかテストする	-9 <= x <= 9
行列と同じ大きさの空配列を作る	np.empty_like(aArray)
プロットの用途を論文に指定する	sns.set(context='paper')
イテラブルとリストについて散布図を描画して、ダイアモンドマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='D', c=rgb)
＜オプション＞アクアマリン色を使用する	color = 'aquamarine'
折れ線グラフの色を青緑に設定する	plt.plot(データ列, データ列2, color='teal')
実数のハイパボリック・タンジェントの逆数を算出する	math.atanh(x)
nをn2倍にする	n *= n2
xを浮動小数点数に変換する	float(x)
重なりを見やすく散布図をパステル調の色のマーカーで描画する	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
データ列の文字列長を列として使う	ds.str.len()
データ列の中に文字列があるか調べる	ds.isin([value])
クリムゾン色の線グラフを描画する	plt.plot(データ列, データ列2, color='crimson')
データフレームが正規分布からどれだけ、歪んでいるか見る	df.kurt()
行列の行ごとの標準偏差を求める	np.std(aArray, axis=1)
配列の行ごとの平均値	np.mean(aArray, axis=1)
黒いポイント印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='k')
列の中に文字列とがいくつあるか数える	ds.isin([value, value2]).sum()
カラムの欠損値を最頻値で置き換える	ds.fillna(ds.mode().iloc[0])
データ列の欠損値をモードに設定する	ds.fillna(ds.mode().iloc[0])
折れ線グラフの色をミディアムオーキッドに設定する	plt.plot(データ列, データ列2, color='mediumorchid')
配列とリストについての散布図を淡い色として描画する	plt.plot(xdata, ydata, c='muted')
nからn2までのスライス	slice(n, n2)
データフレームを二つの列の値によって集計して、列挙する	[(name, group) for name, group in df.groupby(['A', 'B'])]
ヒストグラムを描画して、色をハニーデューに指定する	plt.hist(データ列, color='honeydew')
＜オプション＞整数型を使う	dtype = np.int
日付データが金曜日か判定する	aDate.weekday() == 4
綺麗なグラフを描画する準備をする	import seaborn as sns
リスト内の要素が少なくともひとつ真かどうか調べる	any(aList)
改行なしに二つの文字列をプリントする	print(value, value2, end='')
カウンタからイテラブルを出現回数して引く	aCounter.subtract(iterable)
データフレームを'A'列の値によってグループ化する	df.groupby('A')
リストとリストの折れ線グラフをuntitledとラベル付けして描画する	plt.plot(xdata, ydata, label=untitled)
データフレームのカラムの欠損値を最大値に設定する	df[col].fillna(df[col].max())
両端キューのstart番目からendの部分要素	collections.deque(itertools.islice(deq, start, end))
データフレームを各列と列の組み合わせ毎にグループ化して合計を計算する	df.groupby([column, column2], as_index=False).sum()
データフレームの列の正規分布に対する左右対称性	df[col].kurt()
n2がn以上、かつ、n3以下か	n <= n2 and n2 <= n3
10を底とする対数	math.log10(x)
データフレームの列を1000の位で丸めて、整数にする	df[col].round(-3).astype(int)
データフレームの列の未入力値をxで補う	df[col].fillna(x)
'A'列と'B'列を用いてデータフレームを並べ、、NaNを先頭に来るようにする	df.sort_values(by=['A', 'B'], na_position='first')
リストをビン数nを用いてビン分割して、namesのラベルをつける	pd.cut(aList, n, labels=names)
カウンタのボトムを列挙する	aCounter.most_common()[:-n-1:-1]
二進文字列をバイト列に変換する	int(s, 2).to_bytes(length=bytesize, byteorder='big')
'A'列の値によってデータフレームを分類して、列挙する	[(name, group) for name, group in df.groupby('A')]
折れ線グラフの下三角マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='v', markeredgewidth=n)
＜オプション＞グラフの色をオレンジに設定する	color = 'orange'
ヒストグラムの色をダークサーモンに設定する	plt.hist(データ列, color='darksalmon')
線グラフを描画して、その色をパールゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='palegoldenrod')
折れ線グラフのマーカーを下三角にする	plt.plot(データ列, データ列2, marker='v')
折れ線グラフのラベルをuntitledに設定する	plt.plot(xdata, ydata, label=untitled)
nが5の倍数か調べる	n % 5 == 0
ヒストグラムの線のスタイルを一点鎖線に変更する	plt.hist(データ列, linestyle='dashbot')
データ列の時	ds.dt.hour
selectorsでマスクされたイテラブルの要素を取り出す	itertools.compress(iterable, selectors=iterable2)
日付データが金曜日か調べる	aDate.weekday() == 4
＜オプション＞セパレータをスラッシュにする	sep = '/'
ファイルのディレクトリ名	os.path.dirname(filepath)
リストと数列についての散布図に黒いクロスマーカーを描画する	plt.plot(xdata, ydata, marker='x', c='k')
列を文字列リストに変換して、空白で結合する	' '.join(map(str, iterable))
折れ線グラフの▲マーカーを黒くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
タプルの要素をソートする	sorted(aTuple)
データフレームのカラムの中に文字列があるか調べる	df[col].isin([value])
折れ線グラフを描画して、その色をシャルトリューズに設定する	plt.plot(データ列, データ列2, color='chartreuse')
データ列がどの程度、分散しているか見る	ds.var()
＜オプション＞星マーカーを使う	marker = '*'
実数を切り上げて整数に変換する	math.ceil(x)
nが正の整数	n > 0
ヒストグラムの色をミディアムオーキッドに設定する	plt.hist(データ列, color='mediumorchid')
折れ線グラフを描画して色をミディアムブルーに変更する	plt.plot(データ列, データ列2, color='mediumblue')
データフレームのカラムの空文字を欠損値に変換し、ドロップする	df[col].replace('', np.nan).dropna()
散布図に赤色のダイアモンドマーカーを用いる	plt.plot(xdata, ydata, marker='D', c='r')
エポック秒のデータ列から日付データに変換する	pd.to_datetime(ds, unit='s', utc=True)
＜オプション＞グラフの色をスノーに設定する	color = 'snow'
データ列を使用する	import pandas as pd
３自然数の最小公倍数	math.lcm(n, n2, n3)
ヒストグラムを描画して、その色をパレットトルコイズに設定する	plt.hist(データ列, color='paleturquoise')
＜オプション＞ドジャーブルー色を使う	color = 'dodgerblue'
カラーコードの下三角マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
文字列全体が正規表現に複数行対応としてマッチするか見る	re.fullmatch(pattern, s, flags=re.MULTILINE)
リストと数列について散布図を描画してマーカーをバツに設定する	plt.plot(xdata, ydata, marker='x')
＜オプション＞欠損値も無視しない	dropna = True
キーが辞書に存在するか調べる	key not in aDict
標準出力を得る	sys.stdout
文字列の片仮名をひらがなにする	''.join([chr(ord(ch) - 96) if ('ァ' <= ch <= 'ン') else ch for ch in s])
＜オプション＞ダークオレンジ色を使用する	color = 'darkorange'
＜オプション＞グラフの色をミディアムブルーに指定する	color = 'mediumblue'
ヒストグラムを描画してその色をブルーバイオレットに設定する	plt.hist(データ列, color='blueviolet')
データフレームのカラムのタイムゾーンを日本に設定する	df[col].tz_convert('Asia/Tokyo')
データフレームを'A'列と'B'列によってソートする	df.sort_values(by=['A', 'B'])
部分集合か調べる	aSet.issubset(aSet2)
線グラフの色を耐火レンガに設定する	plt.plot(データ列, データ列2, color='firebrick')
折れ線グラフの色をダーク・スラテグレーに変更する	plt.plot(データ列, データ列2, color='darkslategrey')
折れ線グラフの色をターコイズに設定する	plt.plot(データ列, データ列2, color='turquoise')
折れ線グラフの色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
ヒストグラムの色をミディアムターコイズに設定する	plt.hist(データ列, color='mediumturquoise')
＜オプション＞ライトグリーンに色を変更する	color = 'lightseagreen'
データフレームをグループ化し、それぞれの列に対し標準偏差を求める	df.groupby(column)[column2].std()
リストの文字列の位置をエラーなく使う	aList.index(element) if element in aList else -1
数列と数列について散布図をプロットし、、三角マーカーの色をカラーコードに指定する	plt.plot(xdata, ydata, marker='^', c=rgb)
折れ線グラフを描画して、その色をダークマゼンタに設定する	plt.plot(データ列, データ列2, color='darkmagenta')
ヒストグラムを描画してその色を耐火レンガに設定する	plt.hist(データ列, color='firebrick')
ヒストグラムの色をミディアムスレートブルーに設定する	plt.hist(データ列, color='mediumslateblue')
リストのヒストグラムを描画する	plt.hist(aList)
データフレームを二つの列によって昇順にソートする	df.sort_values(by=['A', 'B'], ascending=True)
データフレームから破壊的に重複した行を削除する	df.drop_duplicates(inplace=True)
エポック秒のデータ列からdatetime64型に変換する	pd.to_datetime(ds, unit='s', utc=True)
数式を簡単化する	sympy.sympify(e)
折れ線グラフを描画して、その色をレモンシフォンに設定する	plt.plot(データ列, データ列2, color='lemonchiffon')
データフレームを列でソートし、、NaNを先頭に来るようにする	df.sort_values(by=column, na_position='first')
赤い明るいの折れ線グラフを描く	plt.plot(xdata, ydata, linestyle='bright', color='r')
データ列を折れ線グラフに描画して、印を三角印にする	plt.plot(データ列, データ列2, marker='^')
データフレームの中で、列と列の重複をドロップする	df.drop_duplicates(subset=[column, column2])
nからn2の値を引いてnに代入する	n -= n2
オールドレースにヒストグラムの色を変更する	plt.hist(データ列, color='oldlace')
＜オプション＞貝殻を使う	color = 'seashell'
ミディアムブルー色のヒストグラムを描画する	plt.hist(データ列, color='mediumblue')
ゼロ埋めした三二ビット整数型の配列	np.zeros(要素数, dtype=np.int16)
データフレームの列の名前を列挙する	df.columns
データフレームをJSONLファイルにWindowsで文字化けしないように書き込む	df.to_csv(filename, encoding='utf_8_sig')
ストリームを改行を取り除いて一行ずつ読む	f.readline()
連立方程式を解く	sympy.solve([e, e2])
Pandasで、文字列をフォーマットで日付データに変換する	pd.to_datetime(s, format='%Y-%m-%d')
文字列の先頭でパターンにASCII限定としてマッチするか確認する	re.match(pattern, s, flags=re.ASCI)
オブジェクトが関数か調べる	callable(obj)
ハニーデュー色の線グラフを描画する	plt.plot(データ列, データ列2, color='honeydew')
インディアンレッドにヒストグラムの色を設定する	plt.hist(データ列, color='indianred')
黒い折れ線グラフを描画する	plt.plot(データ列, データ列2, color='k')
折れ線グラフの色をパールゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='palegoldenrod')
線グラフを描画してその色を紺に設定する	plt.plot(データ列, データ列2, color='darkblue')
折れ線グラフに青い星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='b')
文字列を末尾から空白で区切る	s.rsplit()
データフレームをグループ化し、それぞれの列に対し最大値を求める	df.groupby(column)[column2].max()
配列とデータ列のカラーコードの淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
ヒストグラムの色をミッドナイトブルーに設定する	plt.hist(データ列, color='midnightblue')
ヒストグラムを描画して、色をレモンシフォンに設定する	plt.hist(データ列, color='lemonchiffon')
自然数の階乗	math.factorial(n)
実数から実数を減算する	x - y
＜オプション＞デピンク色を用いる	color = 'deeppink'
ヒストグラムを描画して色をシーグリーンに変更する	plt.hist(データ列, color='seagreen')
線グラフを描画して、その色をサーモンに設定する	plt.plot(データ列, データ列2, color='salmon')
ヒストグラムを描画して、色をペールグリーンに設定する	plt.hist(データ列, color='palegreen')
ヒストグラムを描画してその色をライトシアンに設定する	plt.hist(データ列, color='lightcyan')
リストとデータ列のカラーコードのパステル調のを描画する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
＜オプション＞ダークバイオレット色を使う	color = 'darkviolet'
リストのn番目のの値	aList[n]
方程式として数式を解く	sympy.solve(e)
配列をビン数nでビン分割して、namesのラベルをつける	pd.cut(aArray, n, labels=names)
データフレームの欠損値を最頻値で埋める	df.fillna(df.mode().iloc[0])
n2がnより大きく、かつ、n3未満かどうか確認する	n < n2 and n2 < n3
フクシアにヒストグラムの色を設定する	plt.hist(データ列, color='fuchsia')
スピアマン相関係数としてデータフレームの相関行列を計算する	df.corr(method='spearman')
ふたつの集合がセットと互いに素か調べる	aSet.isdisjoint(aSet2)
ヒストグラムを描画して、その色をレモンシフォンに変更する	plt.hist(データ列, color='lemonchiffon')
データフレームの欠損値を最大値で置換する	df.fillna(df.max())
数列とデータ列の明るいを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='bright', color='k')
データフレームを列によって整列し、、更新する	df.sort_values(by=column, inplace=True)
＜オプション＞分割記号をコロンにする	sep = ':'
バリーウッド色のヒストグラムを描画する	plt.hist(データ列, color='burlywood')
書式を辞書で文字列整形する	formatText.format_map(aDict)
折れ線グラフに星マーカーを加える	plt.plot(データ列, データ列2, marker='*')
コマンドの第一引数を知る	sys.argv[1]
折れ線グラフを描画して、その色をダークグリーンに設定する	plt.plot(データ列, データ列2, color='darkgreen')
ライトイエロー色のヒストグラムを描画する	plt.hist(データ列, color='lightyellow')
小文字が文字列内に含まれるか調べる	any(c.islower() for c in s)
表データを列名リストによってによって降順にソートする	df.sort_values(by=column, ascending=False)
データ列を柱状グラフで可視化する	plt.hist(ds)
行列間の要素ごとの最小公倍数を求める	np.lcm(aArray, aArray2)
＜オプション＞色をサーモンに設定する	color = 'salmon'
文字列の開始位置より後に部分文字列が含まれるか調べる	s.find(sub, start) != -1
データフレームから指定された４つの列のみ抽出する	df[[column, column2, column3, column4]]
暗いグラフの色を青くする	plt.plot(xdata, ydata, linestyle='dark', color='b')
折れ線グラフの色を小麦色に設定する	plt.plot(データ列, データ列2, color='wheat')
全要素を初期値で初期化された行列	np.full((行数, 列数), 初期値, dtype=np.int)
組をn回、連結する	aTuple * n
データフレームをJSONLファイルに保存する	df.to_csv(filename, sep='\t')
nの無限整数リスト	itertools.repeat(n)
データフレームのカラムの欠損値を直前の値で埋める	df[col].fillna(method='ffill')
破線グラフの色を濃いに変更する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
濃いグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
双方向キューを空にする	deq.clear()
キーがマッピングに存在しない時、要素を追加する	aDict.setdefault(key, element)
線グラフを描画して、その色をフォレストグリーンに設定する	plt.plot(データ列, データ列2, color='forestgreen')
ヒストグラムを描画して、その色を小麦色に設定する	plt.hist(データ列, color='wheat')
nをn2だけ右シフトする	n >> n2
エンコーディング	sys.getdefaultencoding()
ゼロ埋めした整数型のベクトル	np.zeros(要素数, dtype=np.int)
オブジェクトのプロパティを値に変更する	setattr(obj, プロパティ名, 値)
折れ線グラフを描画して、その色をゴーストホワイトに指定する	plt.plot(データ列, データ列2, color='ghostwhite')
散布図に右三角マーカーを使う	plt.plot(xdata, ydata, marker='>')
小さい順に複数の列によってデータフレームをソートして、更新する	df.sort_values(by=column, ascending=True, inplace=True)
見やすいプロットを使う準備をする	import seaborn as sns
データフレームのカラムの第一四分位数	df[col].quantile(0.25)
データフレームの文字列を欠損値に変換する	df.replace(s, np.nan)
日付時刻データにn秒を加算する	aDatetime + datetime.timedelta(seconds=n)
Pandasで、文字列のエポック秒からタイムスタンプ型に変換する	pd.to_datetime(s, unit='s', utc=True)
リストを複製する	aList.copy()
浮動小数点数のハイパボリック・サインの逆数を求める	math.asinh(x)
10を底とする実数の対数	math.log10(x)
文字列中にひとつでも非小文字が含まれるかどうか	any(not c.islower() for c in s)
xが真かどうか確認する	bool(x)
グラフで日本語を表示できるようにする	sns.set(font='IPAexGothic')
＜オプション＞改行コードをUNIXに設定する	newline = '\n'
データフレームの欠損値をメディアンに設定する	df.fillna(df.median())
折れ線グラフを描画して、その色をスレートブルーに設定する	plt.plot(データ列, データ列2, color='slateblue')
貝殻色のヒストグラムを描画する	plt.hist(データ列, color='seashell')
＜オプション＞先頭の行をヘッダに設定する	header = 0
ファイルをディレクトリ名とファイル名に分割する	os.path.split(filepath)
オブジェクトが名前付きタプルか調べる	hasattr(obj, '_asdict') and hasattr(obj, '_fields')
等差数列から乱数を求める	random.randrange(start, end, step)
カウンタを辞書で更新する	aCounter.update(aDict)
暗い色のマーカーで散布図を重なりを見やすくプロットする	plt.plot(xdata, ydata, c='dark', alpha=0.5)
２つのカウンタのいずれかに含まれる値	aCounter | aCounter2
セット＼セット	aSet.difference(aSet2)
ヒストグラムの色をミディアムシアグリーンに変更する	plt.hist(データ列, color='mediumseagreen')
n進数文字列をbytesizeバイトのバイト列に変換する	int(s, n).to_bytes(length=bytesize, byteorder='big')
ファイルを全部、読み込む	f.read()
＜オプション＞マーカーをバツに変更する	marker = 'x'
シャルトリューズ色のヒストグラムを描画する	plt.hist(データ列, color='chartreuse')
折れ線グラフの色をフクシアに設定する	plt.plot(データ列, データ列2, color='fuchsia')
標準エラー	sys.stderr
文字列はPythonのキーワードか調べる	keyword.iskeyword(s)
折れ線グラフに大きさnの▼マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markersize=n)
算術計算ライブラリをインポートする	import math
データフレームを昇順に破壊的に二つの列によってソートする	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
データ列の中の欠損値の合計を数える	ds.isna().sum()
＜オプション＞ライトグリーン色を使用する	color = 'lightseagreen'
折れ線グラフの色をデピンクに設定する	plt.plot(データ列, データ列2, color='deeppink')
ファイルパスからバイナリストリームをオープンして]fとする	f = open(filepath, mode='rb')
ロイヤルブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='royalblue')
列をキーにして二つのデータフレームを外部結合する	pd.merge(df, df2, on=column, how='outer')
ファイルパスのセパレータ記号	os.sep
非数を使う	math.nan
文字列が漢字	('\u4E00' <= ch <= '\u9FD0')
行列の行ごとの合計値を求める	np.sum(aArray, axis=1)
書式をマッピングでフォーマットする	formatText.format_map(aDict)
折れ線グラフの色をグレーに変更する	plt.plot(データ列, データ列2, color='gray')
配列をヒストグラムで可視化する	plt.hist(aArray)
＜オプション＞大文字・小文字を無視する	flag = re.IGNORECASE
折れ線グラフに黄色い丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='y')
黒い丸マーカーで散布図を描く	plt.plot(xdata, ydata, marker='o', c='k')
折れ線グラフに黄色いダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
データフレームを列の値によってグループ化して、最小値を求める	df.groupby(column).min()
配列とリストについてパステル調のグラフをプロットして、色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
CSVファイルをデータフレームとして読み込む	pd.read_csv(filename, sep=',')
デピンクにヒストグラムの色を設定する	plt.hist(データ列, color='deeppink')
文字列が全て空白文字からなるか調べる	s.isspace()
＜オプション＞ラベンダー色を使う	color = 'lavender'
n×n2の二次元リスト	[[0] * n for _ in range(n2)]
２つのタプルをチェーンする	collections.ChainMap(aDict, aDict2)
折れ線グラフを描画してその色をグリーンに指定する	plt.plot(データ列, データ列2, color='green')
文字列を部分文字列で分割して、文字列リストにする	s.split(sub)
ヒストグラムを描画し、合計を1にする	plt.hist(データ列, density=True)
正規分布を用いて乱数を生成する	random.normalvariate(mu=0.5, sigma=0.2)
破壊的に重複をデータフレームから削除する	df.drop_duplicates(inplace=True)
ハニーデュー色のヒストグラムを描画する	plt.hist(データ列, color='honeydew')
変数を下線付き化する	f'\033[4m{value}\033[0m'
アクアマリン色のヒストグラムを描画する	plt.hist(データ列, color='aquamarine')
淡いグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
ダークシアグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkseagreen')
ファイルの拡張子をtextに変更する	os.path.splitext(filepath)[0] + text
リストを等しい量になるようにビン数nでビン分割する	pd.qcut(aList, n)
NaN	math.nan
配列の次元を変形する	aArray.reshape(行数, 列数)
＜オプション＞ポイント印を加える	marker = '.'
データフレームのカラムが正規分布からどの程度、歪んでいるか見る	df[col].kurt()
データ列を折れ線グラフに描画して、マーカーを星印にする	plt.plot(データ列, データ列2, marker='*')
＜オプション＞グラフの色をトマトに設定する	color = 'tomato'
＜オプション＞ライトグレーにグラフの色を指定する	color = 'lightgray'
＜オプション＞グラフの色をベージュに設定する	color = 'beige'
パパイヤウィップ色のヒストグラムを描画する	plt.hist(データ列, color='papayawhip')
カウンタから最頻出の要素の件数	aCounter.most_common()[1]
リストの先頭を捨てる	aList[1:]
＜オプション＞ダークオーキッドにグラフの色を変更する	color = 'darkorchid'
ゼロ埋めされた８ビット整数型の配列	np.zeros(要素数, dtype=np.int8)
データフレームのそれぞれのグループ毎の標準偏差	df.groupby(column).std()
リストの先頭を見る	aList[0]
線グラフを描画して、その色をアンティークホワイトに設定する	plt.plot(データ列, データ列2, color='antiquewhite')
＜オプション＞色をアイボリーに設定する	color = 'ivory'
列をキーにして二つのデータフレームを左結合する	pd.merge(df, df2, on=column, how='left')
ヒストグラムの色をライトイエローに設定する	plt.hist(データ列, color='lightyellow')
グラフを論文用に設定する	sns.set(context='paper')
列名を指定された列名リストに置き換える	df.columns = columns
ベクトルを横方向に連結する	np.concatenate([aArray, aArray2], axis=1)
折れ線グラフの色を淡いピンク色に設定する	plt.plot(データ列, データ列2, color='lightpink')
グラフのサイズを指定する	plt.figure(figsize=(width, height))
行列の列ごとの最小値	np.min(aArray, axis=0)
データ列の値が欠損値か調べる	ds.isna()
文字列が漢字か調べる	('\u4E00' <= ch <= '\u9FD0')
＜オプション＞グラフの色を貝殻に指定する	color = 'seashell'
折れ線グラフを描画して、色を青くする	plt.plot(データ列, データ列2, color='b')
データフレームの列が正規分布からどれだけ尖っているか見る	df[col].skew()
データフレームの列がxより大きくx2より小さい行を抽出する	df[(x < df[column]) & (df[column] < x2)]
データ列をビン数nを用いてビン分割する	pd.cut(ds, n)
＜オプション＞色をミディアムシアグリーンに指定する	color = 'mediumseagreen'
折れ線グラフを描画してその色をゲインズボロに設定する	plt.plot(データ列, データ列2, color='gainsboro')
配列を等しい量になるようにビン数nでビン分割する	pd.qcut(aArray, n)
リストとリストについての散布図を濃い色として描く	plt.plot(xdata, ydata, c='deep')
文字列が小文字か確認する	s.islower()
TSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
＜オプション＞シスル色を使う	color = 'thistle'
ヒストグラムを描画して、色をオレンジレッドに設定する	plt.hist(データ列, color='orangered')
データフレームのカラムと列の相関行列をヒートマップを用いて描画する	sns.heatmap(df[[column, column2]].corr())
ヒストグラムの描画して、正規化する	plt.hist(データ列, density=True)
＜オプション＞色をダークオーキッドに設定する	color = 'darkorchid'
数式の変数にnを代入する	e.subs(z, n)
リストとリストについての散布図に四角マーカーを描画する	plt.plot(xdata, ydata, marker='s')
ファイルパスからバイナリストリームを開いて]、fとする	f = open(filepath, mode='rb')
＜オプション＞青色を使用する	color = 'blue'
データフレームを表示するとき、表示可能な最大行数をnに設定する	pd.set_option('display.max_rows', n)
アイボリーにヒストグラムの色を設定する	plt.hist(データ列, color='ivory')
グラフのパレットを全般的に色差別なくする	sns.set(pallete='colorblind')
ポイントマーカーを散布図に用いる	plt.plot(xdata, ydata, marker='.')
列名の一覧をデータ型でフィルタする	df.select_dtypes(型).columns
全印字	string.printable
＜オプション＞バッファリングのサイズを変更する	buffering = 4096
グラフの目的を画面に指定する	sns.set(context='notebook')
＜オプション＞グラフの色をオリーブに設定する	color = 'olive'
辞書をコピーする	aDict.copy()
折れ線グラフの色をライトスカイブルーに設定する	plt.plot(データ列, データ列2, color='lightskyblue')
最小値でデータフレームのカラムの未入力値を埋める	df[col].fillna(df[col].min())
配列と配列についてカラーコードの色差別ないを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
タプルの最初	aTuple[0]
紺色の折れ線グラフを描画する	plt.plot(データ列, データ列2, color='darkblue')
折れ線グラフに黄色いクロスマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='y')
双方向キューの先頭を使う	deq[0]
黒色の大バツマーカーを数列とリストについての散布図に描画する	plt.plot(xdata, ydata, marker='X', c='k')
CSVファイルからデータフレームを読む	pd.read_csv(filename, sep=',')
青緑にヒストグラムの色を設定する	plt.hist(データ列, color='teal')
分子n、分母mの有理数を新規生成する	fractions.Fraction(numerator=n, denominator=m)
＜オプション＞グラフの色をミディアムスプリンググリーンに変更する	color = 'mediumspringgreen'
リストとリストの散布図に丸マーカーを描く	plt.plot(xdata, ydata, marker='o')
カウンタの項目をリストとして得る	aCounter.keys()
配列とリストの折れ線グラフを描画し、、色を文字列に指定する	plt.plot(xdata, ydata, color=s)
列とリストをつなぐ	itertools.chain(iterable, iterable2)
ヒストグラムの色をゴールデンロッドに設定する	plt.hist(データ列, color='goldenrod')
ヒストグラムを描画して、色をダークオレンジに指定する	plt.hist(データ列, color='darkorange')
xが-9以上、9以下か調べる	-9 <= x <= 9
折れ線グラフの色をハニーデューに設定する	plt.plot(データ列, データ列2, color='honeydew')
データフレームを'A'列によって昇順に破壊的に並べる	df.sort_values(by='A', ascending=True, inplace=True)
配列とリストについての散布図を暗い色を使って描画する	plt.plot(xdata, ydata, c='dark')
ダークオレンジ色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkorange')
日付時刻データをエポック秒に変換する	aDatetime.timestamp()
青いヒストグラムを描画する	plt.hist(データ列, color='b')
折れ線グラフを描画して、その色をダークスレートブルーに設定する	plt.plot(データ列, データ列2, color='darkslateblue')
リストとリストについての散布図にポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.')
線グラフを描画して、その色をゲインズボロに設定する	plt.plot(データ列, データ列2, color='gainsboro')
データフレームのカラムが何分か見る	df[col].dt.minute
二つのオブジェクトが同一参照か調べる	obj is obj2
折れ線グラフに黄色いポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='y')
サーモン色のヒストグラムを描画する	plt.hist(データ列, color='salmon')
タプルの先頭を取り除く	aTuple[1:]
＜オプション＞グラフの線種を実線にセットする	linestyle = 'solid'
キーがマップに存在するかどうか調べる	key not in aDict
データフレームの先頭n行を抽出する	df.head(n)
改行除外してファイルを一行ずつ読み込む	f.readline()
データフレームの列のヒストグラムを描画する	plt.hist(df[column])
文字列の開始位置からと終了位置までの間に部分文字列が含まれないか調べる	s.find(sub, start, end) == -1
異なるn個のものからk個選ぶ場合の数	math.comb(n, k)
＜オプション＞ダークグレーを使う	color = 'darkgray'
茶色色のヒストグラムを描画する	plt.hist(データ列, color='brown')
イテラブルから重複なく、n個ランダムに選ぶ	random.sample(iterable, k=n)
浮動小数点数の双曲線正接	math.tanh(x)
データフレームをJSONLファイルにSJISで保存する	df.to_csv(filename, encoding='shift_jis')
棒グラフを描画して、中央寄せする	plt.bar(ラベル列, データ列, align='center')
＜オプション＞グラフの色をラベンダーに設定する	color = 'lavender'
列の値によってデータフレームをグループ分けし、、グループの最大値を求める	df.groupby(column).max()
散布図に右三角マーカーを用いる	plt.plot(xdata, ydata, marker='>')
リストを中央値でビン分割する	pd.qcut(aList, 2)
折れ線グラフを描画して、その色をディープスカイブルーに設定する	plt.plot(データ列, データ列2, color='deepskyblue')
マップからキーの値をエラーなく得る	aDict.get(key, None)
キーがマップ上で未定義	key not in aDict
ヒストグラムの色をラベンダーに変更する	plt.hist(データ列, color='lavender')
サンディーブラウン色のヒストグラムを描画する	plt.hist(データ列, color='sandybrown')
リストとリストの折れ線グラフを描画して、色を文字列に設定する	plt.plot(xdata, ydata, color=s)
白色で変数を出力する	print(f'\033[37m{value}\033[0m')
＜オプション＞グラフの色をレモンシフォンに設定する	color = 'lemonchiffon'
グラフのサイズを横width縦heightに設定する	plt.figure(figsize=(width, height))
文字列を部分文字列で二分し、後半の文字列を求める	s.partition(sub)[-1]
折れ線グラフの色をサーモンに設定する	plt.plot(データ列, データ列2, color='salmon')
今日が何日か知る	datetime.datetime.today().day
データフレームの列と列の相関行列スピアマンでを算出する	df[[column, column2]].corr(method='spearman')
データ列の中に含まれるとの合計を数える	ds.isin([value, value2]).sum()
ヒストグラムを描画して、その色をスレートブルーに指定する	plt.hist(データ列, color='slateblue')
オプションで、標準出力を使う	file = sys.stdout
xでデータフレームのカラムの未入力値を置換する	df[col].fillna(x)
nが1、もしくは2か調べる	n == 1 or n == 2
カラムの値を一度にValueMapで置き換える	ds.replace(ValueMap)
ヒストグラムを描画して、その色をダークターコイズに設定する	plt.hist(データ列, color='darkturquoise')
列を四分位数で分割する	pd.qcut(ds, 4)
全ての８進数字	string.octdigits
シルバーにヒストグラムの色を設定する	plt.hist(データ列, color='silver')
濃い色のヒストグラムでリストを描く	plt.hist(xdata, color='deep')
文字列の右側からタブを取り除く	s.rstrip('\t')
itertoolsモジュールをインポートする	import itertools
折れ線グラフの色をサンディーブラウンに設定する	plt.plot(データ列, データ列2, color='sandybrown')
カウンタの正の数のみ残す	+aCounter
ゼロ埋めされた符号なし８ビット整数型の配列	np.zeros(要素数, dtype=np.uint8)
イテラブルをカウンタにする	collections.Counter(iterable)
双方向キューの末尾にイテラブルの各値を順に追加する	deq.extend(iterable)
リストをビン数nでビン分割する	pd.cut(aList, n)
リストとリストの濃いグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='deep', color='k')
リストとリストのカラーコードの暗いグラフを描く	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
文字列をシンボルにする	sympy.Symbol(s)
データフレームのカラムの種類	df.info()
データフレームのカラムを10の位で四捨五入して、整数型にする	df[col].round(-1).astype(int)
列ごとにデータフレームをグループ分けし、平均値を求める	df.groupby(column).mean()
Pandasで、データ列をフォーマットfmtで日付データにする	pd.to_datetime(ds, format=fmt)
カウンタの項目を列挙する	aCounter.keys()
折れ線グラフを描画して、その色をライトグリーンに指定する	plt.plot(データ列, データ列2, color='lightgreen')
折れ線グラフにバツマーカーを使う	plt.plot(データ列, データ列2, marker='x')
ヒストグラムを描画して、その色をディムグレーに設定する	plt.hist(データ列, color='dimgray')
配列の標準偏差を算出する	np.std(aArray)
最頻値でデータフレームのカラムの欠損値を置換する	df[col].fillna(df[col].mode().iloc[0])
ライトサーモン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightsalmon')
＜オプション＞グラフの色をグレーに設定する	color = 'grey'
ダークバイオレット色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkviolet')
双方向キューをタプルにする	tuple(deq)
＜オプション＞セパレータをコロンにする	sep = ':'
データフレームを'A'列と'B'列によって並べ直してNaNを先頭に来るようにする	df.sort_values(by=['A', 'B'], na_position='first')
ヒストグラムの色をオーキッドに設定する	plt.hist(データ列, color='orchid')
マップからキーの値	aDict.get(key)
データフレームの第三四分位数	df.quantile(0.75)
散布図に左三角マーカーを用いる	plt.plot(xdata, ydata, marker='<')
ヒストグラムの色をダークオリーブグリーンに設定する	plt.hist(データ列, color='darkolivegreen')
＜オプション＞ピーチパフを使用する	color = 'peachpuff'
グラフのカラーパレットをpalleteNameにセットする	sns.set(pallete=palleteName)
データフレームの欠損値を直前の値に設定する	df.fillna(method='ffill')
セットを組に変換する	tuple(aSet)
散布図に黒い四角マーカーを使う	plt.plot(xdata, ydata, marker='s', c='k')
ヒストグラムを描画して、その色をシーグリーンに設定する	plt.hist(データ列, color='seagreen')
リストをパステル調の色のヒストグラムで描画する	plt.hist(xdata, color='pastel')
文字列をエンコーディングでバイト列に変換する	s.encode(encoding=encoding)
実数の逆双曲線正弦	math.asinh(x)
整数nの二進表記	bin(n)
ヒストグラムを描画して、その色をオリベドラブにする	plt.hist(データ列, color='olivedrab')
ふたつの関係が部分集合	aSet.issubset(aSet2)
＜オプション＞グラフの色をスプリンググリーンに設定する	color = 'springgreen'
データフレームを列によってグループ化して、各グループ毎の分散を求める	df.groupby(column).var()
＜オプション＞ディープスカイブルー色を使う	color = 'deepskyblue'
暗い色でヒストグラムを描画する	plt.hist(xdata, color='dark')
散布図にカラーコードの丸マーカーを使う	plt.plot(xdata, ydata, marker='o', c=rgb)
リストと配列についての散布図に星マーカーを描画する	plt.plot(xdata, ydata, marker='*')
ファイルを追加モードでオープンして]、fとする	f = open(filepath, mode='a')
数式を積分する	sympy.integrate(e)
データ列を100の位で丸めて、整数型にする	ds.round(-2).astype(int)
ヒストグラムを描画して、その色をスラグレーに指定する	plt.hist(データ列, color='slategrey')
辞書にキーワード引数で更新する	aDict.update(**kwargs)
折れ線グラフを描画して、色をミスティローズに設定する	plt.plot(データ列, データ列2, color='mistyrose')
折れ線グラフを描画して、その色をダークサーモンに設定する	plt.plot(データ列, データ列2, color='darksalmon')
＜オプション＞パパイヤウィップ色を使う	color = 'papayawhip'
文字列の開始位置以降が部分文字列で始まるか	s.startswith(sub, start)
データフレームのカラムの日	df[col].dt.day
三変数の最大値を求める	max(x, y, z)
データフレームを列の値によってグループ化し、基本統計量を求める	df.groupby(column).describe()
n個の要素があるリスト	[element] * n
リストとリストについての散布図に左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<')
数列と数列について散布図を描画し、、マーカーを▼に設定する	plt.plot(xdata, ydata, marker='v')
本日が土曜日か調べる	datetime.datetime.today().weekday() == 5
リストをマゼンタにする	f'\033[35m{value}\033[0m'
ヒストグラムを描画して、色を紺に指定する	plt.hist(データ列, color='darkblue')
本日を文字列でフォーマットして文字列にする	"datetime.datetime.today().strftime(""%d/%m/%y"")"
ヒストグラムを描画して、その色をコーンズシルクに設定する	plt.hist(データ列, color='cornsilk')
データフレームの列を最初のカテゴリーを除外してワンホット・ベクトルに変換する	pd.get_dummies(df[column], drop_first=True)
データ列の平均値	ds.mean()
文字列を部分文字列で分けた時の後半の文字列	s.partition(sub)[-1]
データ列の欠損値を平均で埋める	ds.fillna(ds.mean())
データフレームをインデックスによって整列する	df.sort_index()
データフレームのカラムをドロップして更新する	df.drop(column, axis=1, inplace=True)
ヒストグラムを描画して、その色をミスティローズに指定する	plt.hist(データ列, color='mistyrose')
折れ線グラフの色をゲインズボロに設定する	plt.plot(データ列, データ列2, color='gainsboro')
散布図にカラーコードの右三角マーカーを使う	plt.plot(xdata, ydata, marker='>', c=rgb)
ヒストグラムを描画して、その色をスプリンググリーンに設定する	plt.hist(データ列, color='springgreen')
グラフの背景色を白くする	sns.set(style='whitegrid')
折れ線グラフに四角マーカーを使う	plt.plot(データ列, データ列2, marker='s')
＜オプション＞ダークスラテグレーを使う	color = 'darkslategray'
シスル色のヒストグラムを描画する	plt.hist(データ列, color='thistle')
グラフで利用可能な色名の一覧	matplotlib.colors.cnames
配列の各要素の最大公約数	np.gcd(aArray, aArray2)
＜オプション＞インデックスを自動的な連番に指定する	index_col = None
列を文字列リストに変換して、空白で連結する	' '.join(map(str, iterable))
再帰の最大回数を知る	sys.getrecursionlimit()
文字列が文字列より辞書順で後	s > s2
淡いピンク色色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightpink')
シーケンスを両端キューに変換する	collections.deque(iterable)
ベクトルを元にして全要素が初期値の配列	np.full_like(aArray, 初期値)
ヒストグラムを描画してその色を暗い赤にセットする	plt.hist(データ列, color='darkred')
ファイルからn文字、読み込む	f.read(n)
折れ線グラフに赤い大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='r')
デックからポップする	deq.pop()
実数を百の位で丸める	round(x, -2)
イテラブルを文字列リストに変換して、カンマで連結する	','.join(map(str, iterable))
データ列とラベルを指定して、縦棒グラフを描く	plt.bar(ラベル列, データ列)
赤色の淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='r')
全要素が初期値の行列	np.full((行数, 列数), 初期値, dtype=np.int)
小さい順に表を'A'列によって破壊的にソートする	df.sort_values(by='A', ascending=True, inplace=True)
ヒストグラムを描画して、色をライトグレーに設定する	plt.hist(データ列, color='lightgray')
グレー色のヒストグラムを描画する	plt.hist(データ列, color='gray')
リストを青色で出力する	print(f'\033[34m{value}\033[0m')
実数の平方根	math.sqrt(x)
リストとリストについての散布図にカラーコードの左三角マーカーをプロットする	plt.plot(xdata, ydata, marker='<', c=rgb)
リストと配列でパステル調のグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
分子n、分母mの有理数を作る	fractions.Fraction(numerator=n, denominator=m)
データ列の歪度	ds.kurt()
データフレームを各列と列の組み合わせ毎にグループ化し、、個数を求める	df.groupby([column, column2], as_index=False).count()
折れ線グラフの色をダークスレートブルーに設定する	plt.plot(データ列, データ列2, color='darkslateblue')
データフレームを複数の列の値によってグループ化する	df.groupby(columns)
リストと配列の折れ線グラフを描画して、untitledとラベル付けする	plt.plot(xdata, ydata, label=untitled)
ヒストグラムを描画して、その色をスラグレーに設定する	plt.hist(データ列, color='slategrey')
＜オプション＞グラフの色をアクアに設定する	color = 'aqua'
二つの列を並べて箱髭図にする	plt.boxplot([df[column], df[column2]])
行列の最大値	np.max(aArray)
文字列は平仮名かどうかテストする	('ぁ' <= ch <= 'ん')
＜オプション＞グラフの色をダークマゼンタに設定する	color = 'darkmagenta'
文字列を積極的に小文字に変換する	s.casefold()
＜オプション＞色をミディアムスレートブルーに設定する	color = 'mediumslateblue'
nからn2を引く	n - n2
折れ線グラフの色をスレートブルーに設定する	plt.plot(データ列, データ列2, color='slateblue')
線グラフの色を淡いピンク色に指定する	plt.plot(データ列, データ列2, color='lightpink')
文字列の両端から空白を取り除く	s.strip()
折れ線グラフを描画して、その色をダークオーキッドに設定する	plt.plot(データ列, データ列2, color='darkorchid')
nが1、もしくは2か	n == 1 or n == 2
黒い大バツマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='k')
＜オプション＞データ型を指定する	dtype = np.int8
青色の暗いをプロットする	plt.plot(xdata, ydata, linestyle='dark', color='b')
小数点数のtan	math.tan(x)
nが一桁の数か調べる	-9 <= n <= 9
散布図にダイアモンドマーカーを使う	plt.plot(xdata, ydata, marker='D')
エクセルデータファイルからnという名前のシートをデータフレームとして読む	pd.read_excel(filename, sheet_name=n)
＜オプション＞ナバホホワイト色を用いる	color = 'navajowhite'
ヒストグラムの色をゴールデンロッドに指定する	plt.hist(データ列, color='goldenrod')
マッピングの項目名と値を入れ替える	{v: k for k, v in aDict.items()}
ヒストグラムを描画して、その色をダークレッドにする	plt.hist(データ列, color='darkred')
重なりを見やすくリストとリストの散布図を淡い色として描画する	plt.plot(xdata, ydata, c='muted', alpha=0.5)
双方向キューから部分を取り出す	collections.deque(itertools.islice(deq, start, end))
＜オプション＞コーンズシルクにグラフの色を設定する	color = 'cornsilk'
線グラフの色をプラムに設定する	plt.plot(データ列, データ列2, color='plum')
リストをnからナンバリングする	enumerate(aList, start=n)
淡いグラフの色を赤色に設定する	plt.plot(xdata, ydata, linestyle='muted', color='r')
文字列を部分文字列で最後から区切る	s.rsplit(sub)
文字列の先頭でASCII限定として正規表現にマッチさせる	re.match(pattern, s, flags=re.ASCI)
文字列内に空白が含まれるか調べる	any(c.isspace() for c in s)
文字列の開始位置と終了位置の間に部分文字列があるかどうか調べる	s.find(sub, start, end) != -1
＜オプション＞グラフの色を茶色に設定する	color = 'brown'
両端キューをイテラブルから新規生成する	collections.deque(iterable)
ビン数nで配列をビン分割してnamesのラベルをつける	pd.cut(aArray, n, labels=names)
折れ線グラフの大バツマーカーを黄色くする	plt.plot(データ列, データ列2, marker='X', markerfacecolor='y')
箱ひげ図を二つ並べる	plt.boxplot([データ列, データ列2])
データフレームを表示するとき、最大列数を変更する	pd.set_option('display.max_columns', n)
小数点数のk進対数	math.log(x, k)
折れ線グラフのマーカーを四角にする	plt.plot(データ列, データ列2, marker='s')
両端キューをタプルに変換する	tuple(deq)
異なるカラムをキーとして二つのデータフレームを結合する	pd.merge(df, df2, left_on='A', right_on='B')
折れ線グラフのダイアモンドマーカーを黒色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='k')
ロイヤルブルーにヒストグラムの色を指定する	plt.hist(データ列, color='royalblue')
列が正規分布からどれだけ、歪んでいるか見る	ds.kurt()
ヒストグラムを描画して、その色をスラグレーに設定する	plt.hist(データ列, color='slategray')
ヒストグラムを描画して、色をライトサーモンに変更する	plt.hist(データ列, color='lightsalmon')
データフレームの行を範囲指定して抽出する	df[start:end]
グラフにx=0の破線を付ける	plt.axvline(x=0, linestyle='dashed')
＜オプション＞プラム色を使う	color = 'plum'
折れ線グラフに青い四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='b')
棒グラフの幅をxに設定する	plt.bar(ラベル列, データ列, width=x)
ヒストグラムの色をピーチパフに設定する	plt.hist(データ列, color='peachpuff')
文字列をカンマで区切って、列挙する	s.split(',')
データフレームのカラムが何日か調べる	df[col].dt.day
＜オプション＞グラフの色をオールドレースに変更する	color = 'oldlace'
year年month月を日付に変換する	datetime.date(year=year, month=month, day=1)
折れ線グラフの色をシルバーに設定する	plt.plot(データ列, データ列2, color='silver')
ヒストグラムを描画して、その色をアンティークホワイトに設定する	plt.hist(データ列, color='antiquewhite')
文字列からISO書式で日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
ヒストグラムを描画してその色をローングリーンに設定する	plt.hist(データ列, color='lawngreen')
文字列をシンボルにして、変数にする	z = sympy.Symbol(s)
折れ線グラフの丸マーカーを黒くする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='k')
折れ線グラフを描画して、色をカーキに設定する	plt.plot(データ列, データ列2, color='khaki')
配列間の要素ごとの最小公倍数	np.lcm(aArray, aArray2)
リネン色の線グラフを描画する	plt.plot(データ列, データ列2, color='linen')
配列を分割数nでビニングする	pd.cut(aArray, n)
８ビット整数型の全要素を０で初期化された行列を作成する	np.zeros(行数, 列数, dtype=np.int8)
ヒストグラムの色をゲインズボロに設定する	plt.hist(データ列, color='gainsboro')
有理数を使う	import fractions
黒い右三角マーカーとして散布図を描く	plt.plot(xdata, ydata, marker='>', c='k')
＜オプション＞色をスラグレーにセットする	color = 'slategrey'
ヒストグラムの色をシルバーに設定する	plt.hist(データ列, color='silver')
折れ線グラフに緑色の大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='g')
日付データが日曜日かどうか	aDate.weekday() == 6
＜オプション＞グラフの色をスラグレーに設定する	color = 'slategray'
折れ線グラフの色をライトスレイグレーにする	plt.plot(データ列, データ列2, color='lightslategray')
データフレームのカラムを百の位で丸めて、整数型にする	df[col].round(-2).astype(int)
ヒストグラムを描画してその色をライトブルーに設定する	plt.hist(データ列, color='lightblue')
ヒストグラムを描画して、その色をダークマゼンタに設定する	plt.hist(データ列, color='darkmagenta')
折れ線グラフを描画して、色をゴーストホワイトに設定する	plt.plot(データ列, データ列2, color='ghostwhite')
カデットブルー色のヒストグラムを描画する	plt.hist(データ列, color='cadetblue')
カウンタを低頻出方から列挙する	aCounter.most_common()[::-1]
データ列の曜日は何日目か見る	ds.dt.dayofweek
データフレームをインデックスによって昇順にソートする	df.sort_index(ascending=True)
既存のファイルをUTF8で追加できるようにオープンする]	open(filepath, mode='a', encoding='utf-8')
シーケンスの重複組み合わせ	itertools.combinations_with_replacement(iterable, n)
xが一桁の数か調べる	-9 <= x <= 9
カウンタを集合にする	set(aCounter)
日付データの曜日を整数で使う	aDate.weekday()
nからn2の範囲	range(n, n2)
year年day月の日付時刻	datetime.datetime(year=year, month=month, day=1)
＜オプション＞四角印を使う	marker = 's'
リストとリストの折れ線グラフを描き、透明度をalphaに設定する	plt.plot(xdata, ydata, alpha=alpha)
二つのカウンタの共通する要素を算出する	aCounter & aCounter2
実行結果を黒色で表示できる文字列に変換する	f'\033[30m{value}\033[0m'
データ列とリストの散布図を描画し、マーカーの色をパステル調のに指定する	plt.plot(xdata, ydata, c='pastel')
折れ線グラフに緑色の三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='g')
線グラフを描画して、その色をミディアムスレートブルーに設定する	plt.plot(データ列, データ列2, color='mediumslateblue')
文字列がタプルの要素でないか調べる	element not in aTuple
日付時刻データの年数	aDatetime.year
散布図に赤色の△マーカーを使う	plt.plot(xdata, ydata, marker='^', c='r')
イテラブルとイテラブルの直積	itertools.product(iterable, iterable2)
配列の合計値	np.sum(aArray)
小さい順にデータフレームを列によって破壊的にソートする	df.sort_values(by=column, ascending=True, inplace=True)
カウンタの要素を増やす	aCounter[element] += 1
折れ線グラフを描画して、その色をハニーデューに設定する	plt.plot(データ列, データ列2, color='honeydew')
データフレームを列を用いてソートして、新しいインデックスを加える	df.sort_values(columns).reset_index()
文字列全体を正規表現にマッチさせる	re.fullmatch(pattern, s)
折れ線グラフのダイアモンドマーカーを黄色くする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
黒い明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color='k')
折れ線グラフを描画して、その色をライトコーラルに設定する	plt.plot(データ列, データ列2, color='lightcoral')
＜オプション＞文字コードtextを使う	encoding = text
折れ線グラフの四角マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='s', markeredgewidth=n)
折れ線グラフにラベルをつける	plt.plot(xdata, ydata, label=untitled)
＜オプション＞ライトコーラル色を使用する	color = 'lightcoral'
データ列と配列で濃いグラフをプロットして、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', color='r')
リストを引数として展開して表示する	print(*aList)
暗い色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='dark', alpha=0.5)
折れ線グラフに右三角マーカーを使う	plt.plot(データ列, データ列2, marker='>')
カラーバーを横向きに付ける	plt.colorbar(orientation='horizontal')
Pandasで、文字列を日付データに変換する	pd.to_datetime(s)
データフレームを'A'列ごとにグループ化して、列挙する	[(name, group) for name, group in df.groupby('A')]
リストをx軸と指定して、数列の変遷を描画する	plt.plot(range(len(xdata)), xdata)
折れ線グラフを数列とデータ列として描いて、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n)
白色の線グラフを描画する	plt.plot(データ列, データ列2, color='white')
ヒストグラムを描画して、その色をビスクに設定する	plt.hist(データ列, color='bisque')
データフレームの列をドロップして、更新する	df.drop(column, axis=1, inplace=True)
＜オプション＞フクシア色を使う	color = 'fuchsia'
折れ線グラフの色をコーンフラワーブルーに設定する	plt.plot(データ列, データ列2, color='cornflowerblue')
＜オプション＞ライトスレイグレー色を使う	color = 'lightslategray'
ダークブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkblue')
＜オプション＞パパイヤウィップ色を使用する	color = 'papayawhip'
配列と同じ大きさの空配列を作る	np.empty_like(aArray)
数列と配列の黒い暗いグラフを描く	plt.plot(xdata, ydata, linestyle='dark', color='k')
色差別ない色を用いてリストとリストについての散布図を描画する	plt.plot(xdata, ydata, c='colorblind')
n個にデータ列をビン分割し、、namesのラベルをつける	pd.cut(ds, n, labels=names)
折れ線グラフの色をダークサーモンに設定する	plt.plot(データ列, データ列2, color='darksalmon')
グラフを使う準備をする	from sympy import N
日付データが日曜日か調べる	aDate.weekday() == 6
＜オプション＞ドジャーブルーにグラフの色を設定する	color = 'dodgerblue'
データフレームから重複する行を消して、入れ替える	df.drop_duplicates(inplace=True)
文字列内にひとつでもアスキー文字が含まれるか調べる	any(c.isascii() for c in s)
カラーコードのバツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x', c=rgb)
プラットホームがMacOSか	sys.platform.startswith('darwin')
リストの要素を昇順にソートする	sorted(aList, reverse=True)
両端キューは空でないか	len(deq) != 0
文字列を青色でプリントできる文字列にする	f'\033[34m{value}\033[0m'
分数モジュールを使用する	import fractions
データフレームを各列と列の組み合わせ毎にグループ化して、分散を求める	df.groupby([column, column2], as_index=False).var()
データフレームから重複した行を残さず、削除する	df.drop_duplicates(keep=False)
リストの要素をソートする	sorted(aList)
＜オプション＞モカシン色を使う	color = 'moccasin'
折れ線グラフを描画して、その色をホットピンクに設定する	plt.plot(データ列, データ列2, color='hotpink')
データフレームを列によってグループ化して、それぞれのグループごとの標準偏差を求める	df.groupby(column).std()
グラフの目的を画面に変更する	sns.set(context='notebook')
折れ線グラフに青い大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='b')
整数nを2進リテラルに変換する	bin(n)
２数の最小値を求める	min(x, y)
列'A'と列'B'をキーとして二つのデータフレームを内部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
＜オプション＞インディアンレッドを使用する	color = 'indianred'
文字列中の文字を列挙する	list(s)
折れ線グラフの三角マーカーを青色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='b')
ヒストグラムの色をダークグレーに設定する	plt.hist(データ列, color='darkgrey')
ファイルを全部読む	f.read()
データ列をビン数nでビン分割してnamesのラベルをつける	pd.cut(ds, n, labels=names)
双方向キューの要素を右にn個分回転させる	deq.rotate(n)
＜オプション＞読み込まないフッタをnに増やす	skipfooter = n
n2がnより大きくかつ、n3未満かどうか調べる	n < n2 and n2 < n3
線グラフを描画して、その色をシルバーに設定する	plt.plot(データ列, データ列2, color='silver')
イテラブルから配列を作る	np.array(iterable)
配列とリストの散布図に黒いポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.', c='k')
＜オプション＞バッファのサイズを変更する	buffering = 4096
グラフで使うフォントをfontNameに指定する	sns.set(font=fontName)
データフレームを列によってグループ化して、それぞれのグループごとの分散を求める	df.groupby(column).var()
配列をn個に分割してnamesのラベルをつける	pd.cut(aArray, n, labels=names)
ヒストグラムを描画して色をダークマゼンタに設定する	plt.hist(データ列, color='darkmagenta')
折れ線グラフの色をグリーンに設定する	plt.plot(データ列, データ列2, color='green')
昇順に'A'列でデータフレームをソートし、、更新する	df.sort_values(by='A', ascending=True, inplace=True)
タイムスタンプデータが木曜日か確認する	aDatetime.weekday() == 3
配列とリストについての散布図を濃い色で描画する	plt.plot(xdata, ydata, c='deep')
リストとデータ列について散布図を描画し、、マーカーを左三角にセットする	plt.plot(xdata, ydata, marker='<')
線グラフを描画して、その色をロイヤルブルーに指定する	plt.plot(データ列, データ列2, color='royalblue')
双方向キューが空か確認する	len(deq) == 0
＜オプション＞グラフの色をコーンズシルクに設定する	color = 'cornsilk'
＜オプション＞下三角マーカーを加える	marker = 'v'
nとn2の和	n + n2
＜オプション＞グラフの色をマルーンに設定する	color = 'maroon'
nとn2のXORを求める	n ^ n2
印字を全部使う	string.printable
リストとリストで明るいグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
nがn2以下、またはn3以上かどうかテストする	n <= n2 or n >= n3
リストとリストについて散布図を描画して、マーカーをダイアモンドに設定する	plt.plot(xdata, ydata, marker='D')
三変数の最小値	min(x, y, z)
折れ線グラフを描画して、その色をオレンジレッドに設定する	plt.plot(データ列, データ列2, color='orangered')
実数のハイパボリック・コサイン	math.cosh(x)
横方向に２つのデータフレームを連結する	pd.concat([df, df2], axis=1)
データフレームを各列毎にグループ分けして、列の平均値を求める	df.groupby(column)[column2].mean()
リストとリストについて青い色差別ないグラフを描く	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
ヒストグラムを描画して、色をビスクに設定する	plt.hist(データ列, color='bisque')
文字列に日本語が使われているか調べる	re.search('[あ-んア-ン\u4E00-\u9FD0]', s)
ライトグレー色のヒストグラムを描画する	plt.hist(データ列, color='lightgrey')
実数の余弦	math.cos(x)
全要素を０で初期化された８ビット整数型の行列	np.zeros(行数, 列数, dtype=np.int8)
無限にイテラブルを繰り返す	itertools.cycle(iterable)
破壊的にデータフレームを複数の列でによって並べる	df.sort_values(by=column, inplace=True)
集合をイミュータブルに変換する	frozenset(aSet)
配列と配列についての散布図にカラーコードの▲マーカーを描く	plt.plot(xdata, ydata, marker='^', c=rgb)
データフレームの行の一覧を使う	df.index
＜オプション＞上三角マーカーを描画する	marker = '^'
データフレームのリスト列の欠損値を平均値で置換する	df[aList].fillna(df[aList].mean())
プロットの用途をスライドにセットする	sns.set(context='talk')
データフレームのカラムの時	df[col].dt.hour
＜オプション＞ポイントマーカーを描画する	marker = '.'
標準エラーを使用する	sys.stderr
線グラフの色をモカシンに設定する	plt.plot(データ列, データ列2, color='moccasin')
線グラフを描画して、その色をホワイトスモークに設定する	plt.plot(データ列, データ列2, color='whitesmoke')
折れ線グラフに線幅nの下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markeredgewidth=n)
両端キューをデキューする	deq.popleft()
二つの変数を同じ値にする	x = y = n
パラメータについて数式のインテグラルを求める	sympy.integrate(e, z)
折れ線グラフの三角マーカーを黄色くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='y')
赤いダイアモンドマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='D', c='r')
ヒストグラムを描画して、その色をレベッカパープルに設定する	plt.hist(データ列, color='rebeccapurple')
ヒストグラムを描画して、その色をライトコーラルに変更する	plt.hist(データ列, color='lightcoral')
区間数をnに設定してヒストグラムを描画する	plt.hist(データ列, bins=n)
文字列が全てアルファベットか調べる	s.isalpha()
折れ線グラフに青いポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='b')
データフレームのリストカラムの欠損値を直後の値で埋める	df[aList].fillna(method='bfill')
＜オプション＞グラフの色をダークスレートブルーに変更する	color = 'darkslateblue'
ヒストグラムの描いて、正規化する	plt.hist(データ列, density=True)
データ列の25パーセンタイル	ds.quantile(0.25)
折れ線グラフのマーカーを三角印にする	plt.plot(データ列, データ列2, marker='^')
データフレームのリストカラムの中にいくつが含まれるか数える	df[aList].isin([value]).sum()
タプルの末尾を取り除く	aTuple[:-1]
データフレームの列とカラムを削除する	df.drop([column, column2], axis=1)
ヒストグラムを一点鎖線で描画する	plt.hist(データ列, linestyle='dashbot')
データ列は何年か見る	ds.dt.year
ヒストグラムの色をオリーブに指定する	plt.hist(データ列, color='olive')
データフレームを関数の値によってグループ化する	df.groupby(関数)
データフレームのリストカラムの欠損値を最大値で埋める	df[aList].fillna(df[aList].max())
無限なリストを得る	itertools.count()
配列と配列の散布図に大バツマーカーを描く	plt.plot(xdata, ydata, marker='X')
列の要約統計量	ds.describe()
組の要素を昇順にソートする	sorted(aTuple, reverse=True)
ヒストグラムの色をライトグレーに設定する	plt.hist(データ列, color='lightgrey')
折れ線グラフのダイアモンド印を黄色くする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
データフレームのリストカラムの中にいくつ欠損値があるか数える	df[aList].isna().sum()
折れ線グラフを描画して、その色をゴールドに設定する	plt.plot(データ列, データ列2, color='gold')
折れ線グラフの左三角マーカーを青くする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='b')
1行だけ標準入力から読む	sys.stdin.readline()
nをn2だけ左シフトする	n << n2
データフレームのリストカラムを整数に丸める	df[aList].round()
データ列の母標準偏差	ds.std(ddof=0)
折れ線グラフに赤い右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='r')
標準出力の出力先がターミナル	os.isatty(sys.stdin.fileno())
データフレームを表示するとき、カラムの最大幅をnに変更する	pd.set_option('max_colwidth', n)
折れ線グラフに黄色い菱形マーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
＜オプション＞インデックスを自動的な連番に増やす	index_col = None
ダイアモンドマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='D')
＜オプション＞マーカーを四角に変更する	marker = 's'
空のチェーンマップ	collections.ChainMap()
線グラフを描画して、その色をシエナにセットする	plt.plot(データ列, データ列2, color='sienna')
十六進表記の文字列を浮動小数点数に変換する	float.fromhex(十六進表記の文字列)
＜オプション＞カデットブルー色を使う	color = 'cadetblue'
オブジェクトをイテラブルにする	iter(obj)
行列の各要素の最大公約数	np.gcd(aArray, aArray2)
要素を両端キューから取り除く	deq.remove(element)
文字列がn回繰り返すイテラブルを得る	itertools.repeat(element, n)
文字列を部分文字列で二分し、前半の文字列を使う	s.partition(sub)[0]
文字列の先頭で大文字・小文字を無視して正規表現にマッチさせる	re.match(pattern, s, flags=re.IGNORECASE)
△マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^')
＜オプション＞文字列の示すエンコーディングを使う	encoding = s
色差別ないグラフをデータ列とデータ列としてプロットして、線幅をnに指定する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
データフレームの列の欠損値を直後の値で埋める	df[col].fillna(method='bfill')
行列の逆行列	np.linalg.inv(aArray)
まとめてデータフレームの列の名前を文字列を文字列に置換する	df.columns = [str(x).replace(s, s2) for x in df.columns]
データフレームの指定された列を配列に変換する	df[column].values
リストとリストについて破線グラフを描画して、その色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
二点間のユークリッド距離	math.dist(point, point2)
＜オプション＞線種を破線に設定する	linestyle = 'dashed'
データフレームを丸めて、整数型にする	df.round().astype(int)
ヒストグラムの色をターコイズに設定する	plt.hist(データ列, color='turquoise')
各列毎にデータフレームをグループ分けして、列の最小値を求める	df.groupby(column)[column2].min()
リストとリストで淡いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
イテラブルとリストについての散布図にカラーコードの左三角マーカーをプロットする	plt.plot(xdata, ydata, marker='<', c=rgb)
カラムの未入力値を前の行の値で埋める	ds.fillna(method='ffill')
いつまでもシーケンスを繰り返す	itertools.cycle(iterable)
＜オプション＞大バツ印を使う	marker = 'X'
文字列の先頭で正規表現に複数行対応としてマッチするか調べる	re.match(pattern, s, flags=re.MULTILINE)
イテラブルからベクトルを作る	np.array(iterable)
マッピングの項目数を参照する	len(aDict)
折れ線グラフを描画して、その色をミディアムパープルに指定する	plt.plot(データ列, データ列2, color='mediumpurple')
ダークマゼンタ色のヒストグラムを描画する	plt.hist(データ列, color='darkmagenta')
ヒストグラムを描画して、色を赤くする	plt.hist(データ列, color='r')
変数名をキーとして、辞書	dict(name=element)
データフレームから指定した3列を選択する	df[[column, column2, column3]]
アクア色の線グラフを描画する	plt.plot(データ列, データ列2, color='aqua')
実数は有限	math.isfinite(x)
整数nを符号付きでバイト列に変換する	n.to_bytes((n.bit_length() + 7) // 8, byteorder='big', signed=True)
文字列中の正規表現を新しい文字列として置換する	re.sub(pattern, newsub, s)
本日を文字列としてフォーマットする	"datetime.datetime.today().strftime(""%d/%m/%y"")"
単位正方行列を作成する	np.identity(N)
オブジェクトが整数型か確認する	isinstance(obj, int)
データフレームの列を型に変換する	df[col] = df[col].astype(ty)
データフレームを列を用いてグループ化してそれぞれのグループの件数を知る	df.groupby(column).size()
ベクトルを列方向に連結する	np.concatenate([aArray, aArray2], axis=0)
ファイルをバイナリモードでオープンして]、fとする	f = open(filepath, mode='rb')
線グラフを描画して、その色をネイビーに設定する	plt.plot(データ列, データ列2, color='navy')
オリベドラブ色の線グラフを描画する	plt.plot(データ列, データ列2, color='olivedrab')
両端キュー中の要素の数を数える	deq.count(element)
リストが空か	len(aList) == 0
文字列を青色にする	f'\033[34m{value}\033[0m'
プラットホームがMacOSか調べる	sys.platform.startswith('darwin')
データフレームを列でグループ化して、それぞれのグループごとの件数を知る	df.groupby(column).size()
文字列を空白で区切って、整数リストに変換する	map(int, s.split())
リストの変化を折れ線グラフで描画する	plt.plot(range(len(xdata)), xdata)
文字列リストを連結して一つの文字列にする	''.join(map(str, iterable))
辞書に要素をキーとして加える	aDict[key] = element
ヒストグラムを描画して、色を青に設定する	plt.hist(データ列, color='blue')
ファイルからバイナリ書き込みストリームをオープンして]、fとする	f = open(filepath, mode='wb')
リストと配列について暗い色の折れ線グラフを描画して、その線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
データフレームを各列毎に分類して、列の平均値を計算する	df.groupby(column)[column2].mean()
リストを逆順にする	aList[::-1]
nが負の数	n < 0
ファイルが存在する	os.path.exists(filepath)
ヒストグラムの色をブラックに設定する	plt.hist(データ列, color='black')
nを八進文字列に変換する	oct(n)[2:]
データフレームの列が正規表現文字列にマッチする行を抽出する	df[df[column].str.match(s)]
＜オプション＞ダークグレーにグラフの色を変更する	color = 'darkgray'
疑似乱数を発生させる	random.random()
データ列の欠損値を最小値で埋める	ds.fillna(ds.min())
折れ線グラフの色をブルーバイオレットに指定する	plt.plot(データ列, データ列2, color='blueviolet')
ヒストグラムを描画して、色をパレットトルコイズに設定する	plt.hist(データ列, color='paleturquoise')
折れ線グラフのポイント印の線幅をnに指定する	plt.plot(データ列, データ列2, marker='.', markeredgewidth=n)
データフレームのリストカラムの欠損値を第二四分位数に増やす	df[aList].fillna(df[aList].median())
二つの集合の差集合	aSet.difference(aSet2)
データフレームの列の標本標準偏差を求める	df[col].std()
折れ線グラフを描画して、色をシーグリーンに設定する	plt.plot(データ列, データ列2, color='seagreen')
リストとリストを折れ線グラフで描画する	plt.plot(xdata, ydata)
文字列を置き換える	s.replace(sub, newsub)
折れ線グラフの色を紺碧に設定する	plt.plot(データ列, データ列2, color='azure')
ヒストグラムの色をミスティローズに設定する	plt.hist(データ列, color='mistyrose')
色差別ないの色を青にする	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
n足すn2	n + n2
集合の全要素が別の集合に含まれるか調べる	aSet.issubset(aSet2)
文字列の末尾が部分文字列か確認する	s.endswith(sub)
黒い三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^', c='k')
＜オプション＞色をシエナに変更する	color = 'sienna'
現在が何時か知る	datetime.date.today().hour
実数を小数点以下第一位で丸める	round(x, 1)
ヒストグラムの色をアイボリーに設定する	plt.hist(データ列, color='ivory')
変数が0に近づくときの数式の極限値を求める	sympy.limit(e, z, 0)
グレー色のヒストグラムを描画する	plt.hist(データ列, color='grey')
＜オプション＞スラグレーにグラフの色を指定する	color = 'slategray'
nがn2で割り切れるか	n % n2 == 0
ダークマゼンタ色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkmagenta')
リストの末尾から要素をポップする	aList.pop()
＜オプション＞ダークシアグリーンを使う	color = 'darkseagreen'
ポスター用にグラフを設定する	sns.set(context='poster')
折れ線グラフの色をインディアンレッドに設定する	plt.plot(データ列, データ列2, color='indianred')
疑似乱数を生成する	random.random()
リストとリストのカラーコードの暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
データフレームのカラムのNaNを中央値で補う	df[col].fillna(df[col].median())
ミディアムスレートブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumslateblue')
折れ線グラフを描画してその色をライトスカイブルーに設定する	plt.plot(データ列, データ列2, color='lightskyblue')
数式を変数についてn階微分する	sympy.diff(e, z, n)
year年day月を日付時刻に変換する	datetime.datetime(year=year, month=month, day=1)
色を全般的に暗くする	sns.set(pallete='dark')
＜オプション＞グラフの色を紺碧に設定する	color = 'azure'
文字列で区切って二つのリストをプリントする	print(value, value2, sep=s)
ヒストグラムを描画して、色をレベッカパープルに変更する	plt.hist(データ列, color='rebeccapurple')
ラジアンの角度	math.degrees(x)
青い▽マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
標準入力から1行だけ読む	sys.stdin.readline()
オブジェクトが組に含まれるか調べる	element in aTuple
線グラフを描画して、その色をパレットトルコイズに設定する	plt.plot(データ列, データ列2, color='paleturquoise')
日付データが月曜日か調べる	aDate.weekday() == 0
データフレームを配列に変換する	df.values
＜オプション＞シーグリーンを使う	color = 'seagreen'
リストとリストについて散布図を描画して、マーカーを左三角に設定する	plt.plot(xdata, ydata, marker='<')
文字列をアンダーライン付きでプリントできる文字列に変換する	f'\033[4m{value}\033[0m'
カウンタを高頻度方から列挙する	aCounter.most_common()
データフレームの内で、列と列の重複を削除する	df.drop_duplicates(subset=column)
ヒストグラムを描画して、色をカーキに設定する	plt.hist(データ列, color='khaki')
データフレームの名前リストで指定された列を削除する	df.drop(columns, axis=1)
カラムの平均値を求める	ds.mean()
＜オプション＞丸マーカーを使う	marker = 'o'
＜オプション＞アクアを使用する	color = 'aqua'
シーグリーン色のヒストグラムを描画する	plt.hist(データ列, color='seagreen')
リストを等間隔でn個にビン分割する	pd.cut(aList, n)
配列が何次元か	aArray.ndim
データフレームのカラムの秒を使う	df[col].dt.second
組をひとつ飛ばしで取り出す	aTuple[::2]
xが一桁の正の数か調べる	0 <= x <= 9
淡いをリストとリストで描いて、線幅をnに変更する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
文字列リストをsepを区切りとして連結する	sep.join(aStringList)
ファイルを追加用にオープンする]	open(filepath, mode='a')
ヒストグラムを描画して、その色をダークグレーに設定する	plt.hist(データ列, color='darkgray')
配列とデータ列の黒い明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color='k')
マッピングをインデント幅nのJSON形式の文字列にする	json.dumps(aDict, ensure_ascii=False, indent=n)
セットをイミュータブルな集合にする	frozenset(aSet)
リストとデータ列についての散布図にダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D')
折れ線グラフに下三角マーカーを使う	plt.plot(データ列, データ列2, marker='v')
タプルを逆順にする	aTuple[::-1]
データフレームを列によってソートして、更新する	df.sort_values(by=column, inplace=True)
日付時刻データが日付時刻データより後ろか調べる	aDatetime > aDatetime2
線グラフの色をダークシアンに設定する	plt.plot(データ列, データ列2, color='darkcyan')
行列の列ごとの標準偏差	np.std(aArray, axis=0)
オーキッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='orchid')
＜オプション＞サンディーブラウン色を使う	color = 'sandybrown'
緑色の上三角マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='g')
文字列がアルファベットか判定する	s.isalpha()
線グラフの色をイエローグリーンに変更する	plt.plot(データ列, データ列2, color='yellowgreen')
データフレームを列によってグループ化して、それぞれのグループごとの最小値を求める	df.groupby(column).min()
ライトブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightblue')
＜オプション＞色をパールゴールデンロッドに設定する	color = 'palegoldenrod'
タブ区切りのファイルからCSVをSJISで読み込む	pd.read_csv(filename, encoding='shift_jis')
データフレームのリストカラムを1000の位で丸めて、整数型にする	df[aList].round(-3).astype(int)
predicateFuncが真となるイテラブルの要素	itertools.dropwhile(predicateFunc, iterable)
折れ線グラフを描画して色をレモンシフォンに設定する	plt.plot(データ列, データ列2, color='lemonchiffon')
日付時刻データが月曜日か調べる	aDatetime.weekday() == 0
バイナリモードでファイルをオープンする]	open(filepath, mode='rb')
2つのデータフレームを異なる列をキーとして全結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
文字列を部分文字列で区切る	s.split(sub)
青にヒストグラムの色を変更する	plt.hist(データ列, color='blue')
線グラフを描画して、その色をミントクリームに設定する	plt.plot(データ列, データ列2, color='mintcream')
データフレームのカラムの中に日付データとが含まれる	df[col].isin([value, value2])
データフレームの各列間の相関係数	df.corr()
＜オプション＞赤にグラフの色を設定する	color = 'red'
複数カラムの関係性を一度に描画する	sns.pairplot(df[[column, column2, column3]])
インデント幅nで、辞書をJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, indent=n)
二つのオブジェクトは同一参照か調べる	obj is obj2
最後のエントリを辞書から取り出す	aDict.popitem()
データフレームを列でソートして下位n件を取り出す	df.sort_values(columns).tail(n)
タプルとタプルを結合する	aTuple + aTuple2
nの二乗	n ** 2
＜オプション＞グラフの色を暗い赤にセットする	color = 'darkred'
複数の列によってでデータフレームを降順にソートする	df.sort_values(by=column, ascending=False)
横棒グラフの幅をxに設定する	plt.barh(ラベル列, データ列, width=x)
実数の正接	math.tan(x)
ヒストグラムの色を白くする	plt.hist(データ列, color='w')
等間隔でリストをn個にビン分割する	pd.cut(aList, n)
データ列とイテラブルについて散布図を描いてマーカーを丸に設定する	plt.plot(xdata, ydata, marker='o')
データフレームのn行以降抽出する	df[n:]
ライトグリーン色のヒストグラムを描画する	plt.hist(データ列, color='lightgreen')
データ列の中にある日付データとの合計を数える	ds.isin([value, value2]).sum()
折れ線グラフの色をラベンダーブラッシュに設定する	plt.plot(データ列, データ列2, color='lavenderblush')
データフレームを表示するとき、カラムの最大幅をnに設定する	pd.set_option('max_colwidth', n)
nが1、もしくは2、もしくは3に等しいか調べる	n == 1 or n == 2 or n == 3
リストとリストについての散布図にカラーコードのバツマーカーを描画する	plt.plot(xdata, ydata, marker='x', c=rgb)
折れ線グラフのポイント印の大きさをnに指定する	plt.plot(データ列, データ列2, marker='.', markersize=n)
リストとリストについて散布図を描画して、左三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='<', c=rgb)
リストの先頭のn要素を取り除く	aList[n:]
データ列の欠損値を直後の値に設定する	ds.fillna(method='bfill')
＜オプション＞シーグリーンに色を設定する	color = 'seagreen'
辞書のキー一覧	list(aDict)
データフレームのカラムの文字列を欠損値に変換する	df[col].replace(s, np.nan)
＜オプション＞NaNも無視しない	dropna = True
データフレームのリストカラムを小数点以下n桁で丸める	df[aList].round(n)
データフレームのn番目の行を抽出する	df.loc[n]
実行時の標準出力の出力先がターミナルか調べる	sys.stdout.isatty()
折れ線グラフを描画して、その色をシエナに設定する	plt.plot(データ列, データ列2, color='sienna')
＜オプション＞グラフの色を紺碧に指定する	color = 'azure'
ヒストグラムを描画して色をミディアムバイオレットレッドに設定する	plt.hist(データ列, color='mediumvioletred')
＜オプション＞改行の代わりに文字列を用いる	end = s
棒を描いて中央寄せする	plt.bar(ラベル列, データ列, align='center')
辞書をネスト化する	collections.ChainMap(aDict)
文字列を部分文字列で分けた場合の前半の文字列	s.partition(sub)[0]
データ列の欠損値をxに設定する	ds.fillna(x)
切り下げて整数に変換する	math.floor(x)
2を底とする実数の対数	math.log2(x)
環境の名前	sys.platform
折れ線グラフを描画して、色をライトゴールドロディイエローに変更する	plt.plot(データ列, データ列2, color='lightgoldenrodyellow')
スノー色のヒストグラムを描画する	plt.hist(データ列, color='snow')
データフレームの空文字をドロップする	df.replace('', np.nan).dropna()
列でデータフレームを集約して、列の要約統計量を算出する	df.groupby(column).describe()[column2]
ヒストグラムの色をペルーに設定する	plt.hist(データ列, color='peru')
配列を一次元にする	aArray.flatten()
JSONL形式のファイルからデータフレームを読む	pd.read_json(filename, orient='records', lines=True)
nがn2か調べる	n == n2
表データを使う	import pandas as pd
データ列を折れ線グラフに描画して、マーカーを左三角印にする	plt.plot(データ列, データ列2, marker='<')
シャルトリューズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='chartreuse')
折れ線グラフを描画して、その色を紺碧に設定する	plt.plot(データ列, データ列2, color='azure')
ヒストグラムの色をカーキに設定する	plt.hist(データ列, color='khaki')
異なる列をキーにして二つのデータフレームを内部ジョインする	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
双方向キューからデータを削除する	deq.remove(element)
ヒストグラムを描画して、色をライトコーラルに設定する	plt.hist(データ列, color='lightcoral')
文字列をカンマで分割して、文字列リストに変換する	s.split(',')
2つのデータフレームを列'A'と列'B'をキーとしてジョインする	pd.merge(df, df2, left_on='A', right_on='B')
＜オプション＞線種を点線に設定する	linestyle = 'dotted'
両端キューから最初の要素を取り除く	deq.remove(element)
ヒストグラムの色をプラムに設定する	plt.hist(データ列, color='plum')
データフレームのカラムを100の位で丸める	df[col].round(-2)
列と列をペアリングする	itertools.zip_longest(iterable, iterable2)
＜オプション＞グラフの色をゴールドに設定する	color = 'gold'
データフレームから型リストで指定されたデータ型のカラムを取り出す	df.select_dtypes(include=typeList)
xの小数点以下'5'桁までの文字列に変換する	':.5f'.format(x)
データフレームのリストカラムの欠損値を第二四分位数で埋める	df[aList].fillna(df[aList].median())
16進数文字列をbytesizeバイトのバイト列に変換する	int(s, 16).to_bytes(length=bytesize, byteorder='big')
線グラフを描画して、その色をティールに設定する	plt.plot(データ列, データ列2, color='teal')
横棒グラフを積み上げにする	"plt.barh(ラベル列, データ列, bottom=データ列2, color=""red"")"
カウンタの項目のカウントを使う	aCounter[element]
データフレームを見る	df.head()
折れ線グラフの色をベージュに設定する	plt.plot(データ列, データ列2, color='beige')
リストとリストについて散布図を描画し、、マーカーをポイントに設定する	plt.plot(xdata, ydata, marker='.')
xを整数に変換する	int(x)
散布図を赤い丸マーカーとして描画する	plt.plot(xdata, ydata, marker='o', c='r')
二つの文字列をスラッシュで区切ってプリントする	print(value, value2, sep='/')
データフレームをグループ化し、それぞれの列に対し分散を求める	df.groupby(column)[column2].var()
折れ線グラフの色をレモンシフォンに設定する	plt.plot(データ列, データ列2, color='lemonchiffon')
＜オプション＞トマト色を使う	color = 'tomato'
配列とリストの散布図に赤い丸マーカーを描く	plt.plot(xdata, ydata, marker='o', c='r')
二つの文字列はケースを無視して同じか	s.casefold() == s2.casefold()
配列から重複を除いた配列を作る	np.unique(aArray)
折れ線グラフを描画して、その色をパウダーブルーに設定する	plt.plot(データ列, データ列2, color='powderblue')
両端キューの先頭にイテラブルの各要素を追加する	deq.extendleft(iterable)
＜オプション＞アクアマリン色を使う	color = 'aquamarine'
数列とリストについてカラーコードのパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
辞書の全をクリアする	aDict.clear()
折れ線グラフの下三角マーカーを黒くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='k')
データフレームを'A'列によって並べて、NaNを先頭にする	df.sort_values(by='A', na_position='first')
文字列を部分文字列で二分する	s.partition(sub)
文字列はタイトルケースか調べる	s.istitle()
凡例をプロットに文字列と文字列と表示する	plt.legend([s, s2])
＜オプション＞ライトグリーン色を用いる	color = 'lightseagreen'
折れ線グラフの三角マーカーを黒くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
リストから重複を取り除く	set(iterable)
ロージーブラウン色の線グラフを描画する	plt.plot(データ列, データ列2, color='rosybrown')
2つのオブジェクトが等しい	obj == obj2
折れ線グラフに赤いクロス印を描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='r')
ヒストグラムの色をチョコレートに指定する	plt.hist(データ列, color='chocolate')
本日が木曜日か	datetime.datetime.today().weekday() == 3
＜オプション＞ブランチドアーモンド色を使う	color = 'blanchedalmond'
データフレームの中で、列と列の重複を調べる	df.duplicated(subset=[column, column2])
データフレームのリスト列の未入力値を最頻値に変更する	df[aList].fillna(df[aList].mode().iloc[0])
データフレームの中で、列と列の重複を削除する	df.drop_duplicates(subset=[column, column2])
組の最初のn要素を捨てる	aTuple[n:]
ダークオーキッド色のヒストグラムを描画する	plt.hist(データ列, color='darkorchid')
変数を太字で表示できる文字列に変換する	f'\033[1m{value}\033[0m'
散布図に丸マーカーを使用する	plt.plot(xdata, ydata, marker='o')
部分文字列で文字列を区切る	s.split(sub)
日付時刻データの曜日を整数で使う	aDatetime.weekday()
文字列がリストに含まれるか調べる	element in aList
文字列のケースをする	s.casefold()
ベージュ色の線グラフを描画する	plt.plot(データ列, データ列2, color='beige')
真上位集合	aSet > aSet2
データフレームのリストカラムの中央値	df[aList].median()
折れ線グラフに緑色の丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='g')
集合にイテラブルの要素を全て追加する	aSet.update(iterable)
オブジェクトがあるクラスのインスタンスか調べる	isinstance(obj, クラス)
ファイルパスをEUCとして追加できるようにオープンする]	open(filepath, mode='a', encoding='euc_jp')
値は集合の要素でないかどうか確認する	element not in aSet
全要素を1で初期化した行列	np.ones(行数, 列数, dtype=np.int)
線グラフの色をオールドレースに指定する	plt.plot(データ列, データ列2, color='oldlace')
データフレームを列によって並べて、新しいインデックスを加える	df.sort_values(columns).reset_index()
データフレームの中に文字列があるかどうか調べる	df.isin([value])
文字列の開始位置以降に部分文字列が含まれないか調べる	s.find(sub, start) == -1
ダークバイオレット色のヒストグラムを描画する	plt.hist(データ列, color='darkviolet')
複数の列によってデータフレームをグループ化し、列挙する	[(name, group) for name, group in df.groupby(columns)]
イテラブルをカウンタに変換する	collections.Counter(iterable)
整数nを十六進数文字列に変換する	hex(n)[2:]
本日が何曜日か知る	datetime.datetime.today().weekday()
＜オプション＞ブランチドアーモンドを使う	color = 'blanchedalmond'
実数がNaNか調べる	math.isnan(x)
＜オプション＞ハニーデュー色を使う	color = 'honeydew'
カウンタから最も頻出な項目の件数を求める	aCounter.most_common()[1]
折れ線グラフに大きさnのポイント印を描画する	plt.plot(データ列, データ列2, marker='.', markersize=n)
データフレームの欠損値を削除する	df.dropna()
パールバイオレットレッド色のヒストグラムを描画する	plt.hist(データ列, color='palevioletred')
アルファベットの大文字を全て見る	string.ascii_uppercase
折れ線グラフの色をコーンズシルクに設定する	plt.plot(データ列, データ列2, color='cornsilk')
データフレームの中で、列と列に重複があるか調べる	df.duplicated(subset=[column, column2])
カラーコードの四角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='s', c=rgb)
折れ線グラフのバツマーカーを黒色にする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='k')
句読点文字を使う	string.punctuation
＜オプション＞グレー色を用いる	color = 'grey'
折れ線グラフの色を暗い赤に設定する	plt.plot(データ列, データ列2, color='darkred')
ゲインズボロにヒストグラムの色を指定する	plt.hist(データ列, color='gainsboro')
折れ線グラフを描画してその色を濃いシアンに変更する	plt.plot(データ列, データ列2, color='darkcyan')
ベクトルの内積	np.dot(aArray, aArray2)
データフレームの中にある文字列の数をカウントする	df.isin([value]).sum()
ヒストグラムの色をグレーにする	plt.hist(データ列, color='gray')
アイボリー色のヒストグラムを描画する	plt.hist(データ列, color='ivory')
＜オプション＞ホワイト色を使う	color = 'white'
アルファベットの小文字列	string.ascii_lowercase
エポック秒を日付時刻に変換する	datetime.datetime.fromtimestamp(timestamp)
イテラブルでカウンタを更新する	aCounter.update(iterable)
散布図に丸マーカーを使う	plt.plot(xdata, ydata, marker='o')
文字列を最初の部分文字列で分けた時の後半の文字列	s.partition(sub)[-1]
標準出力の出力先がターミナル	sys.stdout.isatty()
乱数シードを初期化する	random.seed()
ヒストグラムの色を紺碧に変更する	plt.hist(データ列, color='azure')
折れ線グラフに赤い▽マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='r')
書き込みモードでファイルを開いて]fとする	f = open(filepath, mode='w')
実数を千の位で丸める	round(x, -3)
タプルの要素を昇順にソートする	sorted(aTuple, reverse=False)
リストを白色にする	f'\033[37m{value}\033[0m'
折れ線グラフに赤いバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='r')
イテラブルの重複コンビネーションを得る	itertools.combinations_with_replacement(iterable, n)
双方向キューの左から要素を削除する	deq.popleft()
グラフの全般的にパレットを淡くする	sns.set(pallete='muted')
グラフの用途をスライドに設定する	sns.set(context='talk')
実行時に標準出力がパイプか調べる	not sys.stdout.isatty()
実数を実数で整数除算する	x // y
データフレームのリストカラムの要約統計量	df[aList].describe()
行列の列ごとの合計値を計算する	np.sum(aArray, axis=0)
カウンタ同士でユニオン演算する	aCounter | aCounter2
折れ線グラフを描画して、その色をオーキッドに設定する	plt.plot(データ列, データ列2, color='orchid')
グリーンイエロー色のヒストグラムを描画する	plt.hist(データ列, color='greenyellow')
青紫にヒストグラムの色を設定する	plt.hist(データ列, color='violet')
組の末尾からn番目以前の部分を取り出す	aTuple[:-n]
＜オプション＞ヘッダを自動的な連番に設定する	header = None
ラベンダーにヒストグラムの色を変更する	plt.hist(データ列, color='lavender')
レモンシフォン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lemonchiffon')
リストと数列の青い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='b')
ファイルにxを文字列にして書き込む	f.write(str(x))
集合が空でないか調べる	len(aSet) != 0
データフレームのカラムの中にある文字列の合計を数える	df[col].isin([value]).sum()
データフレームを列によってグループ分けして、それぞれのグループごとの標準偏差を求める	df.groupby(column).std()
日付時刻データが日曜日か調べる	aDatetime.weekday() == 6
フォーマットfmtで文字列を日付データにする	pd.to_datetime(s, format=fmt)
パールゴールデンロッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='palegoldenrod')
ヒストグラムを描画してその色をミディアムターコイズに設定する	plt.hist(データ列, color='mediumturquoise')
折れ線グラフを描画して、その色を黄色に設定する	plt.plot(データ列, データ列2, color='yellow')
折れ線グラフの下三角マーカーを黄色くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='y')
コレクションを使用する	import collections
折れ線グラフに四角印を使う	plt.plot(データ列, データ列2, marker='s')
＜オプション＞ライトサーモンにグラフの色を変更する	color = 'lightsalmon'
黒い四角マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='s', c='k')
折れ線グラフに青い右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='b')
散布図を重なりを見やすく明るい色のマーカーを用いて描画する	plt.plot(xdata, ydata, c='bright', alpha=0.5)
ディムグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='dimgray')
nわるn2	n / n2
配列を分割数nを使ってビン分割し、、namesのラベルをつける	pd.cut(aArray, n, labels=names)
文字列を赤色でプリントする	print(f'\033[31m{value}\033[0m')
リストとリストでパステル調のを描き、、その線幅をnに変更する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
seabornのデフォルトを適用する	sns.set()
＜オプション＞ミディアムアクアマリンを用いる	color = 'mediumaquamarine'
折れ線グラフの色をシアンに設定する	plt.plot(データ列, データ列2, color='cyan')
折れ線グラフの色をダークオレンジに設定する	plt.plot(データ列, データ列2, color='darkorange')
文字列を赤色でプリントできる文字列に変換する	f'\033[31m{value}\033[0m'
折れ線グラフの色を文字列に設定する	plt.plot(xdata, ydata, color=s)
破線グラフの色を濃いにセットする	plt.plot(xdata, ydata, linestyle='dash', color='deep')
実数を切り下げる	math.floor(x)
折れ線グラフを描画して、その色をダークグレーに変更する	plt.plot(データ列, データ列2, color='darkgray')
データフレームの中に文字列と文字列があるか調べる	df.isin([value, value2])
ベクトルを縦方向に連結する	np.concatenate([aArray, aArray2], axis=0)
ダークスラテグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkslategray')
赤いパステル調のの折れ線グラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
Pandasで書式を用いて文字列を日付データに変換する	pd.to_datetime(s, format='%Y-%m-%d')
折れ線グラフを描画してその色をインディゴに変更する	plt.plot(データ列, データ列2, color='indigo')
表データのn行まで抽出する	df[:n]
aListn番目から要素をポップする	aList.pop(n)
赤いダイアモンドマーカーをリストと数列についての散布図に描画する	plt.plot(xdata, ydata, marker='D', c='r')
ファイルを書き込みできるようにオープンする]	open(filepath, mode='w')
＜オプション＞セパレータを使わない	sep = ''
＜オプション＞ダイアモンド印を加える	marker = 'D'
列によってデータフレームをソートして上位n件を取り出す	df.sort_values(columns).head(n)
折れ線グラフの右三角マーカーを緑色にする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='g')
＜オプション＞グラフの色をブラックに指定する	color = 'black'
リストとリストについて明るい色の折れ線グラフを描画して、その線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='bright')
データフレームを各列と列の組み合わせ毎にグループ分けして分散を求める	df.groupby([column, column2], as_index=False).var()
データフレームの先頭	df.head()
配列を一次元化する	aArray.flatten()
リストを番号付けする	enumerate(aList)
データフレームを小さい順に'A'列によってソートして、更新する	df.sort_values(by='A', ascending=True, inplace=True)
淡いカラーパレットをグラフの描画で使う	sns.set(pallete='muted')
＜オプション＞ライトスレイグレーを使う	color = 'lightslategray'
ディムグレー色のヒストグラムを描画する	plt.hist(データ列, color='dimgray')
ロージーブラウン色のヒストグラムを描画する	plt.hist(データ列, color='rosybrown')
赤いダイアモンドマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='r')
データ列のモード	ds.mode()
データフレームの中の欠損値を消す	df.dropna()
８進数字を全部使う	string.octdigits
データ列の中に日付データがあるか調べる	ds.isin([value])
赤い右三角マーカーとして散布図をプロットする	plt.plot(xdata, ydata, marker='>', c='r')
リストのn番目の要素を削除する	del aList[n]
濃い色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
小数点数を実数で割った剰余	math.remainder(x, x2)
＜オプション＞値を置き換える	inplace = True
＜オプション＞バッファリングのサイズを指定する	buffering = 4096
文字列の右側から空白を除去する	s.rstrip()
文字列の開始位置から終了位置までの範囲で部分文字列の登場	s.count(sub, start, end)
nullに等しい値	None
タイムスタンプデータが何年か知る	aDatetime.year
淡いの折れ線を描いて、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
ダークオリーブグリーン色のヒストグラムを描画する	plt.hist(データ列, color='darkolivegreen')
線グラフの色をシスルに設定する	plt.plot(データ列, データ列2, color='thistle')
＜オプション＞ロージーブラウン色を使う	color = 'rosybrown'
折れ線グラフの色をライトコーラルに設定する	plt.plot(データ列, データ列2, color='lightcoral')
リストを等量でビン数nでビン分割する	pd.qcut(aList, n)
＜オプション＞グラフの色をインディアンレッドに設定する	color = 'indianred'
文字列がタプルの要素	element in aTuple
＜オプション＞欠損値を先頭にする	na_position = 'first'
既存のファイルパスを文字コードtextで追加できるようにオープンする]	open(filepath, mode='a', encoding=text)
文字列が片仮名か	('ァ' <= ch <= 'ン')
散布図を赤い右三角マーカーで描画する	plt.plot(xdata, ydata, marker='>', c='r')
横棒グラフの幅をxに指定する	plt.barh(ラベル列, データ列, width=x)
数を小数点以下で丸める	round(x, n)
year年month月day日hour時の日付時刻をオブジェクト化する	datetime.datetime(year=year, month=month, day=day, hour=hour)
データフレームのカラムの秒	df[col].dt.second
日付データにn分を加算する	aDate + datetime.timedelta(minutes=n)
文字列を黄色にする	f'\033[33m{value}\033[0m'
値をマゼンタでプリントできる文字列にする	f'\033[35m{value}\033[0m'
文字列中にひとつでも非アルファベットが含まれるか調べる	any(not c.isalpha() for c in s)
日付データにn日分、加算する	aDate + datetime.timedelta(days=n)
ファイルをオープンして]書き込みストリームを見る	open(filepath, mode='w')
グラフの色を色差別なくする	sns.set(pallete='colorblind')
＜オプション＞ライトスチールブルー色を使う	color = 'lightsteelblue'
線幅nの折れ線グラフを描画する	plt.plot(xdata, ydata, linewidth=n)
xが1、もしくは2、もしくは3に等しいかどうか調べる	x == 1 or x == 2 or x == 3
ヒストグラムの色をグレーにセットする	plt.hist(データ列, color='grey')
折れ線グラフを描画して、その色をダークカーキに変更する	plt.plot(データ列, データ列2, color='darkkhaki')
ヒストグラムの色をダークターコイズに設定する	plt.hist(データ列, color='darkturquoise')
文字列がタプルに含まれないか調べる	element not in aTuple
データフレームを各列と列の組み合わせ毎にグループ化して、最大値を算出する	df.groupby([column, column2], as_index=False).max()
ふたつの関係が上位集合もしくは等しいか確認する	aSet > aSet2
文字列を下線付きにする	f'\033[4m{value}\033[0m'
パステル調の色のマーカーを用いて散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
改行なしに実行結果をプリントする	print(value, end='')
データ列とラベル列を指定して積み上げ横棒グラフを描画する	"plt.barh(ラベル列, データ列, bottom=データ列2, color=""red"")"
データフレームの列が正規表現文字列にマッチしない行を抽出する	df[not df[column].str.match(s)]
項目名がマップに存在していないとき、要素を追加する	aDict.setdefault(key, element)
リストとリストについての散布図に赤い左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c='r')
データ列が正規分布からどれだけ、歪んでいるか見る	ds.kurt()
辞書のキーの値	aDict[key]
分子割る分母	fractions.Fraction(分子, 分母)
ヒストグラムを描画して、その色をベージュに設定する	plt.hist(データ列, color='beige')
データ列をヒストグラムを用いて可視化する	plt.hist(ds)
データフレームの中に文字列がある	df.isin([value])
＜オプション＞色をスレートブルーに設定する	color = 'slateblue'
折れ線グラフの色をミディアムスレートブルーに設定する	plt.plot(データ列, データ列2, color='mediumslateblue')
整数nがタプルのどれか	n in aTuple
＜オプション＞フローラルホワイトにグラフの色を設定する	color = 'floralwhite'
データフレームのカラムの値を正規表現patternでreplに置き換える	df[col].replace(pattern, repl, regex=True)
最大値でデータフレームのカラムの欠損値を置換する	df[col].fillna(df[col].max())
Pandasで、dateStringをPandasの日付型にする	pd.to_datetime(dateString)
最大値・最小値の範囲で一様な疑似乱数を生成する	random.uniform(最小値, 最大値)
＜オプション＞マーカーを右三角に変更する	marker = '>'
表データのn行目を破壊的にドロップする	df.drop(n, axis=0, inplace=True)
二つのデータフレームを異なる列をキーとしてジョインする	pd.merge(df, df2, left_on='A', right_on='B')
データ列の曜日の名前	ds.dt.weekday_name
縦棒を描画して、中央寄せする	plt.bar(ラベル列, データ列, align='center')
文字列の末尾から部分文字列を取り除く	s.rstrip(sub)
＜オプション＞ロージーブラウンにグラフの色を指定する	color = 'rosybrown'
日付データが木曜日か調べる	aDate.weekday() == 3
配列と配列で濃いを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
折れ線グラフの大バツマーカーを青くする	plt.plot(データ列, データ列2, marker='X', markerfacecolor='b')
データ列が正規分布からどの程度、歪んでいるか見る	ds.kurt()
赤い丸マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='o', c='r')
データ列のユニークな値の個数	ds.nunique()
配列の形状	aArray.shape
データ列とリストについての散布図にバツマーカーを描く	plt.plot(xdata, ydata, marker='x')
＜オプション＞貝殻色を使う	color = 'seashell'
異なる列をキーとして二つのデータフレームを左結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='left')
＜オプション＞ディムグレー色を使う	color = 'dimgrey'
黄色い大バツマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='y')
横棒の色をカラーコードに変更する	plt.barh(ラベル列, データ列, color=rgb)
データフレームのリスト列のpercentパーセンタイル	df[aList].quantile(percent/100)
データフレームを列によってグループ化して、それぞれのグループごとの最大値を求める	df.groupby(column).max()
データフレームを列によって破壊的に降順に並べ直す	df.sort_values(by=column, ascending=False, inplace=True)
データ列は何日か見る	ds.dt.day
＜オプション＞グラフの色を紺に設定する	color = 'darkblue'
データ列を箱髭図にする	plt.boxplot(データ列)
ヒストグラムの色をフォレストグリーンに設定する	plt.hist(データ列, color='forestgreen')
ヒストグラムの色をサドルブラウンに設定する	plt.hist(データ列, color='saddlebrown')
パラメータについて数式の微分を算出する	sympy.diff(e, z)
ヒストグラムを描画して、その色をライトグリーンに変更する	plt.hist(データ列, color='lightgreen')
アンティークホワイト色の線グラフを描画する	plt.plot(データ列, データ列2, color='antiquewhite')
ヒストグラムの色を黄色に設定する	plt.hist(データ列, color='yellow')
折れ線グラフのダイアモンドマーカーを青くする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='b')
暗いグラフを描画してその線幅をnに指定する	plt.plot(xdata, ydata, linestyle='dark', color='r')
データ列のUNIX秒から日付データにする	pd.to_datetime(ds, unit='s', utc=True)
nxn2の二次元リストを作る	[[0] * n for _ in range(n2)]
データ列を丸める	ds.round()
データフレームを列の値によってグループ化し、要約統計量を求める	df.groupby(column).describe()
リストとリストの黒い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='k')
キューが空でないかどうか調べる	len(deq) != 0
ヒストグラムの色をライトブルーにセットする	plt.hist(データ列, color='lightblue')
折れ線グラフを実線で描画する	plt.plot(データ列, データ列2, linestyle='solid')
リストが空でない	len(aList) != 0
日付時刻データからn時間分、減算する	aDatetime - datetime.timedelta(hours=n)
タプルの末尾	aTuple[-1]
プロットで使うフォントをfontNameに指定する	sns.set(font=fontName)
nにn2を加える	n + n2
データフレームのカラムの曜日は何日目か見る	df[col].dt.dayofweek
折れ線グラフに大きさnの右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markersize=n)
データフレームの未入力値をモードに設定する	df.fillna(df.mode().iloc[0])
折れ線グラフに描画して、マーカーをバツにする	plt.plot(データ列, データ列2, marker='x')
線グラフを描画して、色をダークオリーブグリーンにセットする	plt.plot(データ列, データ列2, color='darkolivegreen')
リストを四分位数ごとに分割する	pd.qcut(aList, 4)
データフレームから指定された三つの列を抽出する	df[[column, column2, column3]]
実数のアークコサイン	math.acos(x)
青い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='b')
今日をISO書式の文字列に変換する	datetime.datetime.today().isoformat()
リストとリストについての散布図に赤い三角マーカーを描画する	plt.plot(xdata, ydata, marker='^', c='r')
数値の出力を改行なしに行う	print(value, end='')
二つの文字列を文字列で区切ってプリントする	print(value, value2, sep=s)
双方向キューの最後にイテラブルの各値を追加する	deq.extend(iterable)
データフレームを複数の列によって昇順にソートして、更新する	df.sort_values(by=column, ascending=True, inplace=True)
nがn2より大きいか調べる	n > n2
リストと配列について散布図を描画してバツマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='x', c=rgb)
本日の曜日を求める	datetime.datetime.today().weekday()
nがn2の倍数か調べる	n % n2 == 0
データフレームの列を破壊的に削除する	df.drop(column, axis=1, inplace=True)
ペールグリーンにヒストグラムの色を設定する	plt.hist(データ列, color='palegreen')
黒色の色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
Pandasで、文字列のエポック秒から日付データに変換する	pd.to_datetime(s, unit='s', utc=True)
データフレームの数値をまとめて小数点以下n桁で丸める	df.round(n)
ヒストグラムの色をスチールブルーに指定する	plt.hist(データ列, color='steelblue')
データ列の曜日数	ds.dt.dayofweek
リストが空でないか調べる	len(aList) != 0
リストとリストについてパステル調の色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
リストとリストについて散布図を描画して、マーカーの色を濃いに設定する	plt.plot(xdata, ydata, c='deep')
２つ並べて箱ひげ図を描画する	plt.boxplot([データ列, データ列2])
＜オプション＞ライトイエロー色を使う	color = 'lightyellow'
線グラフの色をスノーに設定する	plt.plot(データ列, データ列2, color='snow')
文字列中にひとつでも非数字が含まれる	any(not c.isdigit() for c in s)
データフレームの列の度数分布図を描画する	plt.hist(df[column])
ヒストグラムを描画して、色を耐火レンガに設定する	plt.hist(データ列, color='firebrick')
ヒストグラムを描画して、色を青くする	plt.hist(データ列, color='b')
データフレームで列の重複を調べる	df.duplicated(subset=column)
重なりを見やすく散布図を色差別ない色のマーカーで描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
タブ区切りのファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t')
折れ線グラフの色をマゼンタに設定する	plt.plot(データ列, データ列2, color='magenta')
データフレームの欠損値を直後の値で埋める	df.fillna(method='bfill')
＜オプション＞ドジャーブルーを使う	color = 'dodgerblue'
コロンで文字列を分割し、列挙する	s.split(':')
数値をシアン化する	f'\033[36m{value}\033[0m'
データフレームのリストカラムのNaNを前の行の値で補う	df[aList].fillna(method='ffill')
year年month月day日の日付時刻	datetime.datetime(year=year, month=month, day=day)
データフレームを列の値で集約する	df.groupby(column)
日付データが何曜日か知る	aDate.weekday()
n行をランダムにデータフレームから抽出する	df.sample(n)
データフレームのリストカラムの値を正規表現patternでreplに置き換える	df[aList].replace(pattern, repl, regex=True)
線グラフを描画して、その色をアイボリーに設定する	plt.plot(データ列, データ列2, color='ivory')
線グラフの色をアクアに変更する	plt.plot(データ列, データ列2, color='aqua')
辞書をインデント付きで文字列にする	json.dumps(aDict, ensure_ascii=False, indent=n)
全シートをファイルから読み込む	pd.read_excel(filename, sheet_name=None)
＜オプション＞グラフの色をモカシンに設定する	color = 'moccasin'
折れ線グラフを描画して、その色をグリーンイエローに設定する	plt.plot(データ列, データ列2, color='greenyellow')
カウンタからイテラブルをカウントして引く	aCounter.subtract(iterable)
要素が集合に含まれるか調べる	element in aSet
文字列が文字列より辞書順で前かどうか調べる	s < s2
＜オプション＞グラフの色をビスクに指定する	color = 'bisque'
配列とイテラブルについて散布図を描画して、マーカーを大バツにセットする	plt.plot(xdata, ydata, marker='X')
線グラフの色をスラグレーに変更する	plt.plot(データ列, データ列2, color='slategray')
第2引数で指定されたファイルの名前	sys.argv[1]
文字列を最後の部分文字列で二つに区切って前半の文字列を見る	s.rpartition(sub)[0]
ヒストグラムを描画して、その色をパールゴールデンロッドに指定する	plt.hist(データ列, color='palegoldenrod')
ヒストグラムの色をライムグリーンに設定する	plt.hist(データ列, color='limegreen')
'A'列の値によってデータフレームを集約する	df.groupby('A')
ファイルを改行を取り除いて一行ずつ読み込む	f.readline()
折れ線グラフを描画してその色をローングリーンに変更する	plt.plot(データ列, データ列2, color='lawngreen')
タプルのキーとその値をペアとして取り出す	aDict.items()
両端キューの末尾にイテラブルの各要素を追加する	deq.extend(iterable)
文字列を黄色でプリントできる文字列に変換する	f'\033[33m{value}\033[0m'
データフレームのn行目を取り除いて、更新する	df.drop(n, axis=0, inplace=True)
イテラブルにイテラブルを続ける	itertools.chain(iterable, iterable2)
折れ線グラフを描画して、色を白にセットする	plt.plot(データ列, データ列2, color='white')
実数の双曲線正接の逆数を求める	math.atanh(x)
データフレームをJSONLファイルにヘッダを付けずに書き込む	df.to_csv(filename, header=None)
日付データと日付データの時間差が何秒か知る	(aDate - aDate2).total_seconds()
星マーカーを散布図に用いる	plt.plot(xdata, ydata, marker='*')
＜オプション＞アンティークホワイト色を用いる	color = 'antiquewhite'
カウンタのユニークな要素を列挙する	list(aCounter)
カウンタのユニークな項目をリストとして得る	list(aCounter)
＜オプション＞グリーンイエロー色を使う	color = 'greenyellow'
データフレームの中のカラムをビン数nでビン分割し、、namesのラベルをつける	pd.cut(df[col], n, labels=names)
辞書のコピー	dict(aDict)
淡いグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
折れ線グラフを描画してその色をダークゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='darkgoldenrod')
データフレームの指定された列の名前一覧の列を抽出する	df[columns]
データ列の中の未入力値の合計を数える	ds.isna().sum()
文字列はPythonのキーワードか確認する	keyword.iskeyword(s)
現在の時刻	datetime.date.today().hour
グラフを淡くする	sns.set(pallete='muted')
カラーコードの三角マーカーをリストと配列の散布図に描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
＜オプション＞ライムグリーン色を用いる	color = 'limegreen'
シルバー色の線グラフを描画する	plt.plot(データ列, データ列2, color='silver')
有理数の分子	q.numerator
kを底とする実数の対数	math.log(x, k)
点線グラフを描画する	plt.plot(データ列, データ列2, linestyle='dotted')
タイムスタンプデータとタイムスタンプデータの時間差を秒で求める	(aDatetime - aDatetime2).total_seconds()
グラフの描画でパステル調のカラーパレットを使う	sns.set(pallete='pastel')
列から配列を作る	np.array(iterable)
リストのn番目に文字列を挿入する	aList.insert(n, element)
＜オプション＞印を上三角に変更する	marker = '^'
ヒストグラムを描画して、その色をライトスレイグレーに設定する	plt.hist(データ列, color='lightslategrey')
ヒストグラムの色をライトスレイグレーに設定する	plt.hist(データ列, color='lightslategrey')
データフレームを列によってグループ化して、それぞれのグループごとの個数を求める	df.groupby(column).count()
データフレームの分散	df.var()
折れ線グラフに線幅nの三角印を描画する	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
散布図を大バツマーカーで描画する	plt.plot(xdata, ydata, marker='X')
データ列とリストについて散布図を描画して、クロスマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='x', c=rgb)
ヒストグラムを描画して、色をゲインズボロに設定する	plt.hist(データ列, color='gainsboro')
データフレームを複数の列で集計し、列挙する	[(name, group) for name, group in df.groupby(columns)]
リストと配列について散布図を描画して、大バツマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='X', c=rgb)
データフレームをエクセルファイルファイルでJSONLファイルに書き込む	df.to_excel(filename)
ライトブルー色のヒストグラムを描画する	plt.hist(データ列, color='lightblue')
ターコイズ色のヒストグラムを描画する	plt.hist(データ列, color='turquoise')
＜オプション＞ミディアムオーキッドにグラフの色を設定する	color = 'mediumorchid'
グラフのx軸のラベルをuntitledに指定する	plt.xlabel(untitled)
リストをヒストグラムで可視化する	plt.hist(aList)
＜オプション＞色をシアンに設定する	color = 'cyan'
実数のn乗の実数剰余	pow(x, n, y)
折れ線グラフに下三角マーカーを加える	plt.plot(データ列, データ列2, marker='v')
折れ線グラフに青い菱形印を描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='b')
文字列内に漢字があるか調べる	re.search('[\u4E00-\u9FD0]', s)
ヒストグラムの色をホットピンクに設定する	plt.hist(データ列, color='hotpink')
リストとリストについての散布図に黒いポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.', c='k')
xが1もしくは2かどうか	x == 1 or x == 2
折れ線グラフの左三角マーカーを黒くする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='k')
二つの列によってによって降順にデータフレームを並べる	df.sort_values(by=['A', 'B'], ascending=False)
正規表現によって文字列を置換する	re.sub(pattern, newsub, s)
＜オプション＞カラムの名前を自動的な連番に設定する	header = None
リストとイテラブルについての散布図に黒いダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c='k')
リストの末尾のn要素を取り除く	aList[:-n]
２次元リストの転置行列を計算する	[list(x) for x in list(zip(*aList))]
追加モードとしてファイルをオープンして]fとする	f = open(filepath, mode='a')
データフレームのリストカラムの欠損値をxで埋める	df[aList].fillna(x)
折れ線グラフの三角マーカーを赤くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
空のタプル	()
ベクトルを2次元1行に変形する	aArray.reshape(1, -1)
xが1、もしくは2、もしくは3に等しい	x == 1 or x == 2 or x == 3
タプル中の文字列が最初に見つかるインデックスを探す	aTuple.index(element)
線グラフを描画して、その色をプラムに設定する	plt.plot(データ列, データ列2, color='plum')
プラットホームの名前	sys.platform
ファイルを文字コードtextを用いて書き込み用に開く]	open(filepath, mode='w', encoding=text)
オブジェクトは論理値クラスか調べる	isinstance(obj, bool)
最後の項目を辞書から取り出す	aDict.popitem()
リストとリストの黒い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='k')
折れ線グラフに黒いクロスマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='k')
横棒グラフを描画して、中央寄せする	plt.barh(ラベル列, データ列, align='center')
グラフで使える色名の一覧	matplotlib.colors.cnames
色差別ないグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
折れ線グラフの色をプラムに設定する	plt.plot(データ列, データ列2, color='plum')
スタックの末尾	deq[-1]
数のn乗	pow(x, n)
データ列の月	ds.dt.month
マッピングの項目名を列挙する	aDict.keys()
オブジェクトが数値かどうか確認する	isinstance(obj, (int,float))
リストとリストで色差別ないグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
赤い▼マーカーで散布図を描く	plt.plot(xdata, ydata, marker='v', c='r')
文字列をマゼンタでプリントする	print(f'\033[35m{value}\033[0m')
折れ線グラフを描画して、その色をグリーンに設定する	plt.plot(データ列, データ列2, color='green')
本日が何月か知る	datetime.datetime.today().month
真下位集合	aSet < aSet2
行列のスカラー倍	aArray * n
折れ線グラフの色を青緑に指定する	plt.plot(データ列, データ列2, color='teal')
データフレームの指定された列のみ取り出す	df[[column]]
濃い色の折れ線グラフをプロットしてその線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='deep')
線グラフの色を濃いシアンに設定する	plt.plot(データ列, データ列2, color='darkcyan')
＜オプション＞レモンシフォン色を使う	color = 'lemonchiffon'
線グラフを描画して、その色を淡いピンク色に設定する	plt.plot(データ列, データ列2, color='lightpink')
ヒストグラムの色をダークオレンジに設定する	plt.hist(データ列, color='darkorange')
日付時刻データの秒数	aDatetime.second
折れ線グラフを描画して、その色をコーラルに設定する	plt.plot(データ列, データ列2, color='coral')
暗いの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
リストと配列について散布図を描画して、マーカーの色を濃いに設定する	plt.plot(xdata, ydata, c='deep')
日付時刻データが火曜日かどうか調べる	aDatetime.weekday() == 1
文字列をコロンで区切って、列挙する	s.split(':')
エクセルファイルファイルをデータフレームとして読み込む	pd.read_excel(filename)
データフレームの重複した行数のマスク	df.duplicated()
折れ線グラフに緑色のポイント印を描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='g')
文字列の終了位置まで部分文字列を探す	s.find(sub, 0, end)
データフレームのリストカラムの平均値	df[aList].mean()
二つの数値を順にプリントする	print(value, value2)
データ列とリストの散布図を描画し、、下三角マーカーの色をカラーコードにする	plt.plot(xdata, ydata, marker='v', c=rgb)
折れ線グラフを描画して、その色をシルバーに設定する	plt.plot(データ列, データ列2, color='silver')
整数個のものからk個取り出した場合の並べ方の総数	math.perm(n, k)
＜オプション＞ディムグレーにグラフの色を設定する	color = 'dimgray'
数値を太字でプリントできる文字列に変換する	f'\033[1m{value}\033[0m'
凡例をプロット中の(x,y)の場所に付ける	plt.legend(loc=(x, y))
ファイルをベース名と拡張子に分割する	os.path.splitext(filepath)
タプルに要素をキーとして加える	aDict[key] = element
文字列がリストの要素か確認する	element in aList
真サブセットか	aSet < aSet2
現在処理中の例外を情報を知る	sys.exc_info()
折れ線グラフを描画して、その色をライトグレーに指定する	plt.plot(データ列, データ列2, color='lightgray')
データフレームの列の種類	df.info()
折れ線グラフの色をアンティークホワイトに設定する	plt.plot(データ列, データ列2, color='antiquewhite')
データ列の欠損値を直前の値で埋める	ds.fillna(method='ffill')
両端キューの先頭から要素を取り除く	deq.popleft()
折れ線グラフに描画して、マーカーを右三角にする	plt.plot(データ列, データ列2, marker='>')
配列とリストについてカラーコードのパステル調のグラフを描く	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
実部と虚部から複素数	complex(x, y)
三変数の最大値	max(x, y, z)
ファイルを追加モードでオープンする]	open(filepath, mode='a')
データフレームのリストカラムの中にある文字列の合計を数える	df[aList].isin([value]).sum()
コマンド引数の一覧	sys.argv[1:]
データフレームの列と列の相関行列を求める	df[[column, column2]].corr()
列を等量で分割数nでビニングする	pd.qcut(ds, n)
黒色の右三角マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='>', c='k')
リストとイテラブルについて散布図を描いて、マーカーを左三角に変更する	plt.plot(xdata, ydata, marker='<')
JSONLファイルにデータフレームをタブ区切りとして保存する	df.to_csv(filename, sep='\t')
行列のスカラー倍を求める	aArray * n
＜オプション＞グラフの色をミディアムパープルに設定する	color = 'mediumpurple'
淡いグラフをリストとリストで描画し、、その線幅をnに指定する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
ヒストグラムの色をホワイトスモークに設定する	plt.hist(データ列, color='whitesmoke')
データフレームのリストカラムの中に日付データがあるか	df[aList].isin([value])
列の全順列を得る	itertools.permutations(iterable)
オリーブ色のヒストグラムを描画する	plt.hist(データ列, color='olive')
データフレームのカラムの分	df[col].dt.minute
折れ線グラフの色をペルーに設定する	plt.plot(データ列, データ列2, color='peru')
散布図に赤い右三角マーカーを使う	plt.plot(xdata, ydata, marker='>', c='r')
明るい色でヒストグラムを描画する	plt.hist(xdata, color='bright')
クリムゾン色のヒストグラムを描画する	plt.hist(データ列, color='crimson')
日付時刻データをn分前に戻す	aDatetime - datetime.timedelta(minutes=n)
nプラスn2	n + n2
カウンタの項目のカウント	aCounter[element]
ヒストグラムを描画して、透明度をxに設定する	plt.hist(データ列, alpha=x)
線グラフの色をミディアムパープルに指定する	plt.plot(データ列, データ列2, color='mediumpurple')
0から始まる無限な整数イテラブル	itertools.count()
startからendの区間のヒストグラムを用いてリストを描画する	plt.hist(データ列, range=(start, end))
オブジェクトのオブジェクト識別子	id(obj)
数式を部分分数に展開する	sympy.apart(e)
ヒストグラムの色をサドルブラウンに指定する	plt.hist(データ列, color='saddlebrown')
文字列の中の大文字・小文字を無視してパターンによる全てのマッチを使う	re.findall(pattern, s, flags=re.IGNORECASE)
折れ線グラフにサイズnの右三角印を描画する	plt.plot(データ列, データ列2, marker='>', markersize=n)
データ列を小数点以下n桁で丸める	ds.round(n)
データフレームのカラムの日を見る	df[col].dt.day
集合から全要素を取り除く	aSet.clear()
線グラフの色をダークカーキにセットする	plt.plot(データ列, データ列2, color='darkkhaki')
ヒストグラムを描画して、その色をサーモンに変更する	plt.hist(データ列, color='salmon')
＜オプション＞ダークスレートブルー色を使う	color = 'darkslateblue'
数列とリストについての散布図にカラーコードの▽マーカーを描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
CSVファイルファイル名がかどうか	filename.endswith('.csv')
現在のミリ秒	int(time.time() * 1000)
ひとつでも英数字が文字列内にある	any(c.isalnum() for c in s)
データフレームのNaNを平均に設定する	df.fillna(df.mean())
タプルのn番目からn2番目までの部分	aTuple[n:n2]
＜オプション＞紺碧に色を設定する	color = 'azure'
折れ線グラフの色を淡い茶色に指定する	plt.plot(データ列, データ列2, color='tan')
データフレームのどの値が頻出か見る	df.mode()
ファイルのフォルダ名を使う	os.path.dirname(filepath)
データフレームを表示するときカラムの最大幅をnに設定する	pd.set_option('max_colwidth', n)
両端キューの要素をインプレースに反転する	deq.reverse()
ヒストグラムの色をスノーに設定する	plt.hist(データ列, color='snow')
ゼロ埋めされた整数型のベクトル	np.zeros(要素数, dtype=np.int)
多い順にカウンタを列挙する	aCounter.most_common()
折れ線グラフの色をグリーンイエローに指定する	plt.plot(データ列, データ列2, color='greenyellow')
タイムスタンプデータからn秒を減らす	aDatetime - datetime.timedelta(seconds=n)
リストとリストについてカラーコードの明るいグラフを描く	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
折れ線グラフの色をバリーウッドに設定する	plt.plot(データ列, データ列2, color='burlywood')
明るいを描き、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
シーケンスの長さを制限する	collections.deque(iterable, maxlen=n)
コレクションを使う	import collections
赤い左三角マーカーをリストとリストについての散布図にプロットする	plt.plot(xdata, ydata, marker='<', c='r')
10を底とする実数の対数を求める	math.log10(x)
データフレームのカラムの25パーセンタイル	df[col].quantile(0.25)
文字列の左側から部分文字列を取り除く	s.lstrip(sub)
データフレームの列が文字列が含まれないデータを抽出する	df[not df[column].str.contains(s)]
スチールブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='steelblue')
データフレームを'A'列によって大きい順に破壊的にソートする	df.sort_values(by='A', ascending=False, inplace=True)
＜オプション＞色をティールに設定する	color = 'teal'
データ列とリストについて散布図をプロットして、マーカーをバツに設定する	plt.plot(xdata, ydata, marker='x')
＜オプション＞グラフの色をライトスチールブルーに変更する	color = 'lightsteelblue'
データフレームのカラムが何年か見る	df[col].dt.year
折れ線グラフのポイントマーカーを青くする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='b')
現在の分数	datetime.date.today().minute
実数を切り上げる	math.ceil(x)
暗いの色を赤にする	plt.plot(xdata, ydata, linestyle='dark', color='r')
折れ線グラフを描画して、その色をコーンフラワーブルーに指定する	plt.plot(データ列, データ列2, color='cornflowerblue')
データ列の欠損値を中央値で埋める	ds.fillna(ds.median())
十六進数文字列を整数に変換する	int(s, 16)
線グラフの色をオールドレースに変更する	plt.plot(データ列, データ列2, color='oldlace')
データ列を十の位で丸めて、整数型にする	ds.round(-1).astype(int)
＜オプション＞色をホットピンクに変更する	color = 'hotpink'
実数の小数点以下を丸める	round(x)
nが負の数か調べる	n < 0
折れ線グラフの四角印の線幅をnに指定する	plt.plot(データ列, データ列2, marker='s', markeredgewidth=n)
データフレームの欠損値を直後の値で置換する	df.fillna(method='bfill')
リストを明るい色のヒストグラムで描画する	plt.hist(xdata, color='bright')
データ列を10の位で四捨五入する	ds.round(-1)
二つの集合の∪を使う	aSet.union(aSet2)
数式の平方根を求める	sympy.sqrt(e)
＜オプション＞バッファリングを無効にする	buffering = 0
ファイル全体を行単位で分割してリストに変換する	[s.strip() for s in f.readlines()]
＜オプション＞ゴールド色を使う	color = 'gold'
要素が全て1の配列を作る	np.ones(要素数, dtype=np.int)
折れ線グラフに青い丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='b')
文字列が全てアスキー文字か調べる	s.isascii()
日付時刻データを文字列でフォーマットして文字列に変換する	"aDatetime.strftime(""%d/%m/%y"")"
データ列を折れ線グラフに描画してマーカーをポイントにする	plt.plot(データ列, データ列2, marker='.')
＜オプション＞ライトグリーンに色を変更する	color = 'lightgreen'
散布図にカラーコードの右三角マーカーを用いる	plt.plot(xdata, ydata, marker='>', c=rgb)
逆順の両端キュー	reversed(deq)
全ての印字可能な文字	string.printable
＜オプション＞ライトブルーを使う	color = 'lightblue'
データフレームの重複する行数を数える	df.duplicated().sum()
ヒストグラムを描画して、その色をベージュに変更する	plt.hist(データ列, color='beige')
リストを縦軸、リストを横軸として、大きさnの散布図を描画する	plt.scatter(xdata, ydata, s=n)
2つのデータフレームを列'A'と列'B'をキーとして外部ジョインする	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
ライトサーモン色のヒストグラムを描画する	plt.hist(データ列, color='lightsalmon')
＜オプション＞文字コードtextを使用する	encoding = text
＜オプション＞ゴーストホワイトを使う	color = 'ghostwhite'
３整数の最小公倍数	math.lcm(n, n2, n3)
ヒストグラムを描画して、その色をミディアムブルーに設定する	plt.hist(データ列, color='mediumblue')
折れ線グラフを描画して、その色をライトグリーンに設定する	plt.plot(データ列, データ列2, color='lightseagreen')
折れ線グラフを描画して、その色をスラグレーに設定する	plt.plot(データ列, データ列2, color='slategrey')
プラットホームはMacOSか確認する	sys.platform.startswith('darwin')
ヒストグラムの色をグリーンに設定する	plt.hist(データ列, color='green')
nの十六進表現	hex(n)
文字列からformatのパターンでタイムスタンプに変換する	datetime.datetime.strptime(日付の書かれた文字列, format)
リストを行列に変換する	np.array(aList)
データフレームの列と列を削除する	df.drop([column, column2], axis=1)
折れ線グラフのバツマーカーを緑色にする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='g')
プラットホームがLinuxか確認する	sys.platform.startswith('linux')
タプルを昇順にソートする	sorted(aTuple, reverse=False)
＜オプション＞グラフの色を青紫に設定する	color = 'violet'
列の各データが何回出現するか見る	df[col].value_counts()
文字列を最後の部分文字列で二分する	s.rpartition(sub)
データフレームのリストカラムの欠損値を直後の値で補う	df[aList].fillna(method='bfill')
データフレームの重複した行を数える	df.duplicated().sum()
リストと数列について破線グラフを描画し、その色を明るいに指定する	plt.plot(xdata, ydata, linestyle='dash', color='bright')
日付時刻データの年	aDatetime.year
数式を展開する	sympy.expand(e)
ヒストグラムを描画して、その色をミスティローズに設定する	plt.hist(データ列, color='mistyrose')
二つのデータフレームを横方向に連結する	pd.concat([df, df2], axis=1)
タプルの要素を昇順にソートする	sorted(aTuple, reverse=True)
グラフの用途を論文に設定する	sns.set(context='paper')
パステル調の色のマーカーとして散布図を描画する	plt.plot(xdata, ydata, c='pastel')
データ列のNaNをxに設定する	ds.fillna(x)
データフレームのそれぞれのグループごとの平均値	df.groupby(column).mean()
ヒストグラムの色をダークゴールデンロッドに設定する	plt.hist(データ列, color='darkgoldenrod')
浮動小数点数に変換する	float(x)
データフレームを二つの列によってソートして、NaNを先頭にする	df.sort_values(by=['A', 'B'], na_position='first')
折れ線グラフにダイアモンドマーカーを用いる	plt.plot(データ列, データ列2, marker='D')
配列とリストについての散布図に黒い四角マーカーを描く	plt.plot(xdata, ydata, marker='s', c='k')
空白文字を全て使う	string.whitespace
二つの列によって昇順にデータフレームを並べる	df.sort_values(by=['A', 'B'], ascending=True)
データフレームを各列毎にグループ化して、文字列というグループを求める	df.groupby(column).get_group(s)
ヒストグラムを描画して、その色をインディゴに設定する	plt.hist(データ列, color='indigo')
グラフにx=0の実線を付ける	plt.axvline(x=0, linestyle='solid')
文字列の右側から空白を取り除く	s.rstrip(' ')
TSV形式のファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
nではない	not n
全要素を０で初期化された3２ビット整数型の行列	np.zeros(行数, 列数, dtype=np.int16)
リストとリストについて破線グラフを描画して、その色を濃いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
データフレームのリストカラムの欠損値を最小値に指定する	df[aList].fillna(df[aList].min())
マッピングのキーとその値を列挙する	aDict.items()
関数の値によってデータフレームをグループ化する	df.groupby(関数)
辞書の内部もコピーする	{k: copy.copy(v) for k, v in aDict.items()}
アークサイン	math.asin(x)
大文字列	string.ascii_uppercase
集合から全ての要素を取り除く	aSet.clear()
カーキ色のヒストグラムを描画する	plt.hist(データ列, color='khaki')
＜オプション＞色をライトゴールドロディイエローにする	color = 'lightgoldenrodyellow'
折れ線グラフの大バツマーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='X', markersize=n)
ヒストグラムの色をパールゴールデンロッドに設定する	plt.hist(データ列, color='palegoldenrod')
＜オプション＞読み込みモードを使う	mode = 'r'
日付時刻データが水曜日か調べる	aDatetime.weekday() == 2
＜オプション＞シルバー色を使う	color = 'silver'
ベクトルの和を求める	aArray + aArray2
整数nを半分にする	n //= 2
データフレームのリストカラムの中に文字列と文字列があるか調べる	df[aList].isin([value, value2])
パールバイオレットレッドにヒストグラムの色を設定する	plt.hist(データ列, color='palevioletred')
カウンタのそれぞれの項目を、そのカウントだけリストとして得る	aCounter.elements()
ヒストグラムを描画して、色をミントクリームに設定する	plt.hist(データ列, color='mintcream')
オブジェクトが名前付きタプル	hasattr(obj, '_asdict') and hasattr(obj, '_fields')
リストを等量でn個にビン分割する	pd.qcut(aList, n)
青い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
＜オプション＞色をダークレッドに設定する	color = 'darkred'
＜オプション＞三角マーカーを描画する	marker = '^'
ファイルをオープンして]、バイナリストリームを使う	open(filepath, mode='rb')
データフレームのリスト列を100の位で四捨五入して、整数型にする	df[aList].round(-2).astype(int)
ヒストグラムを描画して、その色をバリーウッドに指定する	plt.hist(データ列, color='burlywood')
配列を行方向に連結する	np.concatenate([aArray, aArray2], axis=1)
y軸のラベルをuntitledに設定する	plt.ylabel(untitled)
ガンマ関数の絶対値に自然対数をとった値	math.lgamma(x)
明るい色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='bright')
ヒストグラムを描画してその色をクリムゾンにセットする	plt.hist(データ列, color='crimson')
データフレームから型リストのデータ型の列を除外する	df.select_dtypes(exclude=typeList)
データ列とラベルを指定して、棒グラフを描画する	plt.bar(ラベル列, データ列)
＜オプション＞グラフの色を暗い赤に設定する	color = 'darkred'
折れ線グラフの四角マーカーを赤くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='r')
データフレームのカラムを1000の位で四捨五入する	df[col].round(-3)
＜オプション＞グラフの色をサンディーブラウンに指定する	color = 'sandybrown'
データフレームの列の中に存在する文字列と文字列の合計を数える	df[col].isin([value, value2]).sum()
正弦	math.sin(x)
＜オプション＞文字コードを文字コードtextに設定する	encoding = text
タプルの最後からn番目以前の部分を取り出す	aTuple[:-n]
＜オプション＞書き込みモードを使う	mode = 'w'
全要素を初期値で初期化された配列	np.full(要素数, 初期値, dtype=np.int)
＜オプション＞シスルにグラフの色を変更する	color = 'thistle'
＜オプション＞ダークグレー色を使う	color = 'darkgray'
カラムの上位25%	ds.quantile(0.25)
データフレームの中で列の重複を見る	df.duplicated(subset=column)
JSON形式の文字列をデータに変換する	json.loads(jsonString)
本日が金曜日	datetime.datetime.today().weekday() == 4
＜オプション＞ライトコーラルにグラフの色を指定する	color = 'lightcoral'
文字列全体が正規表現にマッチするか調べる	re.fullmatch(pattern, s)
＜オプション＞ダークシアンにグラフの色を指定する	color = 'darkcyan'
暗いの折れ線グラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
散布図を▽マーカーで描く	plt.plot(xdata, ydata, marker='v')
データ列の分	ds.dt.minute
折れ線グラフを描画して、その色をダーク・スラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategrey')
リストと配列の折れ線グラフをカラーコードでプロットする	plt.plot(xdata, ydata, color=rgb)
＜オプション＞色をマゼンタに設定する	color = 'magenta'
ファイルを読み込みモードでオープンして]、fとする	f = open(filepath, mode='r')
折れ線グラフの色をライトグレーに指定する	plt.plot(データ列, データ列2, color='lightgray')
データフレームの値を正規表現で置き換える	df.replace(pattern, repl, regex=True)
データフレームを'A'列の値によって集約する	df.groupby('A')
文字列リストを連結してひとつの文字列にする	''.join(map(str, iterable))
データ列の欠損値を最頻値で埋める	ds.fillna(ds.mode().iloc[0])
偽	False
リストとリストについて散布図を描画して、四角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='s', c=rgb)
折れ線グラフを描画して、その色をホワイトスモークに設定する	plt.plot(データ列, データ列2, color='whitesmoke')
折れ線グラフを描画して、色をインディアンレッドに指定する	plt.plot(データ列, データ列2, color='indianred')
列'A'と列'B'をキーにして二つのデータフレームを結合する	pd.merge(df, df2, left_on='A', right_on='B')
カウンタから辞書を引く	aCounter.subtract(aDict)
year年month月day日hour時minute分の日付時刻	datetime.datetime(year=year, month=month, day=day, hour=hour, minute=minute)
データフレームのリスト列は正規分布からどの程度、歪んでいるか見る	df[aList].kurt()
日付時刻データが何日か知る	aDatetime.day
バリーウッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='burlywood')
リストとリストの濃いグラフを描画して色を黒にする	plt.plot(xdata, ydata, linestyle='deep', color='k')
菱形マーカーとして散布図をプロットする	plt.plot(xdata, ydata, marker='D')
リストとリストについての散布図を色差別ない色で描画する	plt.plot(xdata, ydata, c='colorblind')
集合が空	len(aSet) == 0
データフレームのリスト列のNaNをxに設定する	df[aList].fillna(x)
データ列の未入力値をモードで置換する	ds.fillna(ds.mode().iloc[0])
データフレームのカラムがどの程度、分散しているか調べる	df[col].var()
＜オプション＞ミディアムスプリンググリーンを使う	color = 'mediumspringgreen'
ヒストグラムを描画して、色をゴールドに設定する	plt.hist(データ列, color='gold')
データフレームを複数の列によって大きい順に破壊的にソートする	df.sort_values(by=column, ascending=False, inplace=True)
折れ線グラフの色をブラックに変更する	plt.plot(データ列, データ列2, color='black')
ミディアムターコイズ色のヒストグラムを描画する	plt.hist(データ列, color='mediumturquoise')
下三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='v')
＜オプション＞グラフの色をミディアムオーキッドに設定する	color = 'mediumorchid'
データフレームの列の中のNaNの個数をカウントする	df[col].isna().sum()
ヒストグラムを描画して、その色をスカイブルーにセットする	plt.hist(データ列, color='skyblue')
ヒストグラムの色をアリスブルーに設定する	plt.hist(データ列, color='aliceblue')
双方向キューの末尾にイテラブルの各要素を入れる	deq.extend(iterable)
リストとリストの黒い色差別ないを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
ふたつの集合に共通する要素からなる集合	aSet.intersection(aSet2)
文字列を最後の部分文字列で分けたときの前半の文字列を取り出す	s.rpartition(sub)[0]
グラフの描画で明るいカラーパレットを使う	sns.set(pallete='bright')
nとkのnCk	math.comb(n, k)
データフレームの相関行列	df.corr()
リストをn回接続する	aList * n
データフレームから重複を取り除く	df.drop_duplicates()
正規化された柱状図を描画する	plt.hist(データ列, density=True)
整数nの八進表現	oct(n)
ミントクリーム色の線グラフを描画する	plt.plot(データ列, データ列2, color='mintcream')
＜オプション＞グラフの色をライトシアンに指定する	color = 'lightcyan'
文字列が全て数字かどうか確認する	s.isdigit()
＜オプション＞茶色を用いる	color = 'brown'
ヒストグラムを描画して、その色をダークシアグリーンに変更する	plt.hist(データ列, color='darkseagreen')
グリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='green')
青いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='b')
線グラフを描画してその色をペールグリーンに設定する	plt.plot(データ列, データ列2, color='palegreen')
コサイン	math.cos(x)
ゴールド色の線グラフを描画する	plt.plot(データ列, データ列2, color='gold')
ヒストグラムの色をネイビーに設定する	plt.hist(データ列, color='navy')
データフレームのカラムの値が欠損値かどうか	df[col].isna()
データフレームの中で何行、重複するか見る	df.duplicated().sum()
リストとリストの暗いグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='dark', color='k')
要素が辞書の値として含まれているか	element in aDict.values()
カラムの値を正規表現patternでまとめてreplに置き換える	ds.replace(pattern, repl, regex=True)
標準入力から1文字だけ読み込む	sys.stdin.read(1)
ビスク色のヒストグラムを描画する	plt.hist(データ列, color='bisque')
イテラブルから新しいカウンタを生成する	collections.Counter(iterable)
散布図に黒い星マーカーを使う	plt.plot(xdata, ydata, marker='*', c='k')
グラフのカラーパレットを淡くする	sns.set(pallete='muted')
現在のモジュール	sys.modules[__name__]
タプルにイテラブルを続けたイテラブル	itertools.chain(iterable, iterable2)
プラムにヒストグラムの色を設定する	plt.hist(データ列, color='plum')
ヒストグラムの色をダークシアグリーンに設定する	plt.hist(データ列, color='darkseagreen')
数式の数値を求める	float(e)
まとめてreplに正規表現patternでデータフレームのカラムを置き換える	df[col].replace(pattern, repl, regex=True)
＜オプション＞ネイビーに色を変更する	color = 'navy'
折れ線グラフの色をピンクに設定する	plt.plot(データ列, データ列2, color='pink')
ヒストグラムを描画してその色を貝殻に変更する	plt.hist(データ列, color='seashell')
数式を変数について微分する	sympy.diff(e, z)
線グラフを描画して、その色をライトブルーに変更する	plt.plot(データ列, データ列2, color='lightblue')
文字列を二分する	s.partition(sep)
赤い下三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='v', c='r')
両端キューをポップする	deq.pop()
パステル調のグラフをリストと配列で描画して、その線幅をnに指定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
ヒストグラムを描画して、その色をブランチドアーモンドにセットする	plt.hist(データ列, color='blanchedalmond')
折れ線グラフの左三角マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='<', markeredgewidth=n)
グラフの色を明るくする	sns.set(pallete='bright')
ファイルを読み込みモードとしてオープンして]、fとする	f = open(filepath, mode='r')
ヒストグラムの色をライトイエローに変更する	plt.hist(データ列, color='lightyellow')
折れ線グラフの菱形マーカーの線幅をnに変更する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
JSONファイルのファイル入力を読み込んでdataとする	data = json.load(fin)
折れ線グラフの色を赤に設定する	plt.plot(データ列, データ列2, color='red')
整数nをn2分の一にする	n //= n2
散布図を重なりを見やすく色差別ない色のマーカーを用いてプロットする	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
タプルの中の最も大きい値	max(aTuple)
文字列中に部分文字列が含まれるか調べる	sub in s
折れ線グラフの菱形マーカーを緑色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='g')
折れ線グラフに黄色い三角印を描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='y')
リストと配列で明るいを描いて、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color='r')
ヒストグラムを描画して、その色をラベンダーブラッシュにする	plt.hist(データ列, color='lavenderblush')
データフレームの文字列を欠損値に変換する	df.replace(s, np.nan)
変数をマゼンタで表示する	print(f'\033[35m{value}\033[0m')
箱ひげ図でデータ列を可視化する	plt.boxplot(データ列)
＜オプション＞スレートブルー色を使う	color = 'slateblue'
配列を等量でn個に分割する	pd.qcut(aArray, n)
辞書のキーとその値を列挙する	aDict.items()
折れ線グラフを描画して、その色をライトグレーに設定する	plt.plot(データ列, データ列2, color='lightgray')
データフレームの数値を一度に小数点以下n桁で丸める	df.round(n)
ヒストグラムを描画して、その色をスレートブルーにセットする	plt.hist(データ列, color='slateblue')
パウダーブルー色のヒストグラムを描画する	plt.hist(データ列, color='powderblue')
＜オプション＞先頭の列をインデックスに変更する	index_col = 0
データフレームのインデックスの一覧を見る	df.index
淡い色で配列についてのヒストグラムを描く	plt.hist(xdata, color='muted')
リストを濃い色のヒストグラムで描画する	plt.hist(xdata, color='deep')
ヒストグラムを描画して、その色をライトグレーに設定する	plt.hist(データ列, color='lightgray')
折れ線グラフを描画して、その色を青緑に設定する	plt.plot(データ列, データ列2, color='teal')
Pandasで、エポック秒の文字列から日付データに変換する	pd.to_datetime(s, unit='s', utc=True)
タプルの文字列が最初に見つかるインデックスを見る	aTuple.index(element)
ファイルをバイナリモードでオープンする]	open(filepath, mode='rb')
イテラブルからサンプリングする	random.sample(iterable)
データフレームとしてTSVファイルを読み込む	pd.read_csv(filename, sep='\t')
リストとリストで色差別ないグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
文字列を空白で分割して、文字列リストに変換する	s.split()
配列を2次元1列に変形する	aArray.reshape(-1, 1)
＜オプション＞マルーン色を使う	color = 'maroon'
＜オプション＞エラーがあるとき例外を発生させるように指定する	errors = 'strict'
ピアソンでデータフレームの列と列の相関行列を計算する	df[[column, column2]].corr(method='pearson')
折れ線グラフを描画して、その色をコーンズシルクに設定する	plt.plot(データ列, データ列2, color='cornsilk')
Pandasで、データ列をタイムスタンプ型にする	pd.to_datetime(ds)
自然対数の底を使う	math.e
ロードされたモジュールの一覧	sys.modules
文字列を変数化して、変数にする	z = sympy.Symbol(s)
スクリプトファイルのディレクトリパス	os.path.dirname(os.path.abspath(__file__))
フローラルホワイト色のヒストグラムを描画する	plt.hist(データ列, color='floralwhite')
データフレームのカラムの欠損値を直後の値に増やす	df[col].fillna(method='bfill')
リストとリストについて散布図を描画して左三角マーカーの色をカラーコードに変更する	plt.plot(xdata, ydata, marker='<', c=rgb)
データ列を折れ線グラフに描画して、マーカーを大バツにする	plt.plot(データ列, データ列2, marker='X')
折れ線グラフを描画して、色を貝殻に指定する	plt.plot(データ列, データ列2, color='seashell')
nの無限数列	itertools.repeat(n)
淡いグラフの色を青色に変更する	plt.plot(xdata, ydata, linestyle='muted', color='b')
オブジェクトのプロパティの値	getattr(obj, プロパティ名)
ヒストグラムを描画して色をミディアムスレートブルーに指定する	plt.hist(データ列, color='mediumslateblue')
ヒストグラムの色をゴールドに設定する	plt.hist(データ列, color='gold')
データフレームの内の列と列に重複があれば、消す	df.drop_duplicates(subset=column)
整数nを16進リテラルに変換する	hex(n)
折れ線グラフの丸マーカーを黄色くする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='y')
データフレームをインデックスによってソートする	df.sort_index()
マップの浅いコピーを用意する	aDict.copy()
改行なしに文字列をプリントする	print(value, end='')
文字列リストを連結してひとつの文字列にする	''.join(aStringList)
nにn2を足して代入する	n += n2
リストを下線付きでプリントする	print(f'\033[4m{value}\033[0m')
両端キューの順序を右にn個分ローテンションする	deq.rotate(n)
実数の２乗	x ** 2
カウンタの項目数	len(aCounter)
ヒストグラムを描画してその色をディープスカイブルーに設定する	plt.hist(データ列, color='deepskyblue')
リストとリストの濃いグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='deep', color='b')
折れ線グラフを描画して、その色をカーキに設定する	plt.plot(データ列, データ列2, color='khaki')
ユニークな要素ごとの頻度	np.unique(aArray, return_counts=True)
データフレームの列がxより多い行を抽出する	df[df[column] > x]
線グラフの色をパープルに設定する	plt.plot(データ列, データ列2, color='purple')
ファイルをバイナリ書き込みモードを使ってオープンして]、fとする	f = open(filepath, mode='wb')
破線としてヒストグラムを描画する	plt.hist(データ列, linestyle='dashed')
折れ線グラフの丸マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='o', markeredgewidth=n)
折れ線グラフを描画して、その色をライトイエローにセットする	plt.plot(データ列, データ列2, color='lightyellow')
データフレームの中の列と列に重複があれば、削除する	df.drop_duplicates(subset=[column, column2])
データフレームが正規分布からどの程度、歪んでいるか見る	df.kurt()
空白	' '
整数nを八進文字列に変換する	oct(n)[2:]
実数のn乗して実数による余り	pow(x, n, y)
データフレームの中のカラムを等量でn個にビン分割する	pd.qcut(df[col], n)
赤色の右三角マーカーをリストとリストについての散布図にプロットする	plt.plot(xdata, ydata, marker='>', c='r')
ヒストグラムの色をライトグリーンに設定する	plt.hist(データ列, color='lightseagreen')
プラットホームはリナックスか確認する	sys.platform.startswith('linux')
オプションで、標準出力に出力する	file = sys.stdout
ふたつの集合が共通の要素を持たないか調べる	aSet.isdisjoint(aSet2)
両端キューをリストに変換する	list(deq)
タプルの末尾を使う	aTuple[-1]
実数の二乗を計算する	x ** 2
データ列とリストの暗いグラフを描画して、色を黒にする	plt.plot(xdata, ydata, linestyle='dark', color='k')
データフレームを表示するときn行までデータフレームを表示できるようにする	pd.set_option('display.max_rows', n)
データフレームのリストカラムの値が欠損値か調べる	df[aList].isna()
データ列の空文字をドロップする	ds.replace('', np.nan).dropna()
ヒストグラムの色をベージュに変更する	plt.hist(データ列, color='beige')
ペールグリーンにヒストグラムの色を変更する	plt.hist(データ列, color='palegreen')
全ての句読点文字	string.punctuation
データ列の欠損値を最大値に設定する	ds.fillna(ds.max())
カラムを10の位で丸めて整数型にする	ds.round(-1).astype(int)
ビン数をnに設定してヒストグラムを描く	plt.hist(データ列, bins=n)
データ列の値を正規表現patternでまとめてreplに置き換える	ds.replace(pattern, repl, regex=True)
タプルをn倍する	aTuple * n
nが奇数か調べる	n % 2 == 1
カラムのNaNを平均で埋める	ds.fillna(ds.mean())
黒い星マーカーで散布図を描く	plt.plot(xdata, ydata, marker='*', c='k')
データフレームを関数の値によってグループ化し記述統計量を計算する	df.groupby(関数).describe()
折れ線グラフを描画してその色をペルーに変更する	plt.plot(データ列, データ列2, color='peru')
リストとリストの色差別ないをプロットして、色を青にする	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
折れ線グラフに大きさnの大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markersize=n)
データ列をタイムスタンプに変換し、データフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(ds))
データフレームを丸めて、整数にする	df.round().astype(int)
折れ線グラフに緑色のダイアモンド印を描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='g')
デピンク色の線グラフを描画する	plt.plot(データ列, データ列2, color='deeppink')
アルファベットを全て見る	string.ascii_letters
行列のユニークな要素とその位置	u, indices = np.unique(aArray, return_index=True)
文字列を文字コードでバイト列に変換する	s.encode(encoding=encoding)
リストとリストの散布図に右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>')
折れ線グラフの丸マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='o', markersize=n)
折れ線グラフを描画して色をダークバイオレットに変更する	plt.plot(データ列, データ列2, color='darkviolet')
黒い三角マーカーをデータ列とリストについての散布図に描画する	plt.plot(xdata, ydata, marker='^', c='k')
ファイルが存在するか調べる	os.path.exists(filepath)
散布図に黒いダイアモンドマーカーを使う	plt.plot(xdata, ydata, marker='D', c='k')
双方向キューが空でないかどうか調べる	len(deq) != 0
文字列の最初の文字	s[0]
カラムの中に文字列と日付データがある	ds.isin([value, value2])
折れ線グラフに大きさnのダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markersize=n)
辞書のキーの値を参照する	aDict[key]
折れ線グラフを描画して、色をマゼンタに指定する	plt.plot(データ列, データ列2, color='magenta')
ベクトルの最小を求める	np.min(aArray)
文字列に日本語が含まれるか調べる	re.search('[あ-んア-ン\u4E00-\u9FD0]', s)
タイムスタンプデータと日付時刻データの時間差を秒数で求める	(aDatetime - aDatetime2).total_seconds()
アリスブルー色のヒストグラムを描画する	plt.hist(データ列, color='aliceblue')
ヒストグラムを描画して、その色をダークサーモンに設定する	plt.hist(データ列, color='darksalmon')
文字列の開始位置以降に部分文字列がないかどうか調べる	s.find(sub, start) == -1
＜オプション＞バイナリモードを使用する	mode = 'rb'
表データを複数の列によってソートして、更新する	df.sort_values(by=column, inplace=True)
線グラフを描画して、その色をドジャーブルーに設定する	plt.plot(データ列, データ列2, color='dodgerblue')
データフレームのリストカラムの未入力値を平均値に設定する	df[aList].fillna(df[aList].mean())
データフレームの列が正規表現文字列にマッチするデータを抽出する	df[df[column].str.match(s)]
青色のヒストグラムを描画する	plt.hist(データ列, color='blue')
折れ線グラフのダイアモンドマーカーを赤くする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='r')
ヒストグラムの色をゴーストホワイトに設定する	plt.hist(データ列, color='ghostwhite')
データ列のどの値が頻出か見る	ds.mode()
実数の指数部を求める	math.frexp(x)[1]
数列とリストについて散布図を描き、、マーカーをダイアモンドに設定する	plt.plot(xdata, ydata, marker='D')
データフレームのリストカラムの欠損値を最小値で埋める	df[aList].fillna(df[aList].min())
データフレームの列の中に存在する文字列の個数を求める	df[col].isin([value]).sum()
ヒストグラムの色をアンティークホワイトに設定する	plt.hist(データ列, color='antiquewhite')
データフレームの数値を丸める	df.round()
スラグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='slategrey')
黒い大バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='X', c='k')
行列の内積	np.dot(aArray, aArray2)
三自然数の最大公約数	math.gcd(n, n2, n3)
データフレームから破壊的に重複する行をドロップする	df.drop_duplicates(inplace=True)
データ列の欠損値をxで埋める	ds.fillna(x)
ヒストグラムを描画してその色をホワイトに設定する	plt.hist(データ列, color='white')
ファイルの拡張子なしのファイル名を求める	os.path.splitext(os.path.basename(filepath))[0]
リストをy座標リストをx座標と指定して折れ線グラフを描画する	plt.plot(xdata, ydata)
マッピングの内部もコピーする	{k: copy.copy(v) for k, v in aDict.items()}
ヒストグラムを描画して、その色をトマトに設定する	plt.hist(データ列, color='tomato')
データフレームをグループ化し、各列に対し合計を計算する	df.groupby(column)[column2].sum()
ゴールドにヒストグラムの色を設定する	plt.hist(データ列, color='gold')
今日は何月か知る	datetime.datetime.today().month
データフレームのカラムの欠損値を最頻値で埋める	df[col].fillna(df[col].mode().iloc[0])
データフレームのリストカラムの欠損値を直後の値に設定する	df[aList].fillna(method='bfill')
データ列の値をValueMapでまとめて置き換える	ds.replace(ValueMap)
3つの最も小さい値	min(x, y, z)
ヒストグラムを描画してその色をアンティークホワイトにセットする	plt.hist(データ列, color='antiquewhite')
文字列内に空白が含まれるかどうか確認する	any(c.isspace() for c in s)
文字列を太字でプリントする	print(f'\033[1m{value}\033[0m')
データフレームからカテゴリデータの列名を列挙する	df.select_dtypes('object').columns
データフレームの相関行列をヒートマップで描画する	sns.heatmap(df.corr())
最大値・最小値を用いて乱数を生成する	random.randint(最小値, 最大値)
折れ線グラフの▽マーカーを青くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
日付時刻データをn時間前に戻す	aDatetime - datetime.timedelta(hours=n)
nとn2が等しいか調べる	n == n2
大文字と小文字を入れ替える	s.swapcase()
データフレームのリストカラムの欠損値を最大値に設定する	df[aList].fillna(df[aList].max())
配列の和	aArray + aArray2
数値の符号をコピーにする	math.copysign(x, x2)
データフレームの列の文字列が正規表現文字列にマッチするデータを抽出する	df[df[column].str.match(s)]
データフレームを表示するとき、折り返しをしない	pd.set_option('expand_frame_repr', False)
折れ線グラフの色をティールにセットする	plt.plot(データ列, データ列2, color='teal')
配列のスカラー倍	aArray * n
ヒストグラムを描画してその色をピンクに設定する	plt.hist(データ列, color='pink')
n＋n2	n + n2
0から始まる無限なイテラブルを得る	itertools.count()
折れ線グラフを描画して、色をダークバイオレットに設定する	plt.plot(データ列, データ列2, color='darkviolet')
ヒストグラムを描画して、その色をネイビーに設定する	plt.hist(データ列, color='navy')
全要素を０で初期化されたブール型の行列	np.zeros(行数, 列数, dtype=np.int32)
イテラブルを累加した列を得る	itertools.accumulate(iterable)
データフレームのカラムを小数点以下n桁で四捨五入する	df[col].round(n)
小数点数の双曲線正弦	math.sinh(x)
データ列を使う	import pandas as pd
＜オプション＞オーキッド色を用いる	color = 'orchid'
追加できるようにUTF8としてファイルをオープンする]	open(filepath, mode='a', encoding='utf-8')
nが組のどれかか確認する	n in aTuple
折れ線グラフを描画して、その色をオリーブに設定する	plt.plot(データ列, データ列2, color='olive')
＜オプション＞グラフの色をダークオレンジに設定する	color = 'darkorange'
折れ線グラフを描画して、その色を小麦色に指定する	plt.plot(データ列, データ列2, color='wheat')
日付データををn秒後に進める	aDate + datetime.timedelta(seconds=n)
濃いの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
リストとリストを用いてパステル調のの折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
ヒストグラムを描画して、色を茶色に設定する	plt.hist(データ列, color='brown')
実数が有限か調べる	math.isfinite(x)
カラーコードの下三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='v', c=rgb)
イテラブルの全順列	itertools.permutations(iterable)
線グラフを描画して、色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
標準入力から1行だけ読み込んで、改行を取り除く	sys.stdin.readline().rstrip()
データフレームのリストカラムの値を一度にValueMapで置き換える	df[aList].replace(ValueMap)
柱状グラフを描画して、nにビンを設定する	plt.hist(データ列, bins=n)
ヒストグラムの色をダークシアグリーンに指定する	plt.hist(データ列, color='darkseagreen')
データフレームをグループ化し、それぞれの列に対し最小値を求める	df.groupby(column)[column2].min()
＜オプション＞ダークブルー色を使う	color = 'darkblue'
文字列をセパレータで分割して、文字列リストに変換する	s.split(sep)
折れ線グラフの色を白に変更する	plt.plot(データ列, データ列2, color='white')
CSVファイルでデータフレームをJSONLファイルに保存する	df.to_csv(filename)
nまでの奇整数列を得る	list(range(1, n, 2))
フローラルホワイトにヒストグラムの色を設定する	plt.hist(データ列, color='floralwhite')
列の一覧を確認する	df.info()
インデント幅nで、マッピングをJSON形式の文字列にする	json.dumps(aDict, ensure_ascii=False, indent=n)
キーで指定された項目をマッピングからポップする	aDict.pop(key)
最大長nの両端キューを作る	collections.deque(maxlen=n)
十六進文字列をバイト列にする	int(s, 16).to_bytes(length=bytesize, byteorder='big')
＜オプション＞グラフの色をダークグリーンに指定する	color = 'darkgreen'
配列を等しい量になるようにn個にビン分割する	pd.qcut(aArray, n)
集合に値を追加する	aSet.add(element)
データフレームのカラムの欠損値をxに設定する	df[col].fillna(x)
列にシーケンスを続けたイテラブルを得る	itertools.chain(iterable, iterable2)
折れ線グラフを描画して、その色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategray')
線グラフを描画して、その色をパパイヤウィップに設定する	plt.plot(データ列, データ列2, color='papayawhip')
散布図に星マーカーを使う	plt.plot(xdata, ydata, marker='*')
日付時刻データをn秒前に戻す	aDatetime - datetime.timedelta(seconds=n)
リストとリストについて散布図を描画して、マーカーを下三角にする	plt.plot(xdata, ydata, marker='v')
配列をリストを境界値としてビン分割する	pd.cut(aArray, aList)
データフレームの中にある文字列と文字列の数を数える	df.isin([value, value2]).sum()
折れ線グラフを描画して、その色をゲインズボロに設定する	plt.plot(データ列, データ列2, color='gainsboro')
明るいグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
横棒を描画し、、グラフ幅をxにセットする	plt.barh(ラベル列, データ列, width=x)
リストとデータ列のパステル調のグラフを描画してその色を黒にする	plt.plot(xdata, ydata, linestyle='pastel', color='k')
配列から1個ランダムに選ぶ	random.choice(iterable)
文字列の両端から部分文字列を取り除く	s.strip(sub)
日付時刻データの時刻を使う	aDatetime.time()
ヒストグラムを描画して、その色を青緑に指定する	plt.hist(データ列, color='teal')
年月日と時刻から日付時刻	datetime.datetime(年, 月, 日, 時, 分, 秒)
両端キューの末尾から要素を取り除く	deq.pop()
JSONLファイルからデータフレームを読み込む	pd.read_json(filename, orient='records', lines=True)
リストを等間隔でn個に分割する	pd.cut(aList, n)
折れ線グラフに右三角マーカーを使用する	plt.plot(データ列, データ列2, marker='>')
カウンタのキーとカウントをリストとして得る	aCounter.items()
year年month月day日の日付	datetime.date(year=year, month=month, day=day)
＜オプション＞ミディアムブルーにグラフの色を指定する	color = 'mediumblue'
JSON形式の文字列を読み込む	json.loads(jsonString)
散布図に赤色のダイアモンドマーカーを使用する	plt.plot(xdata, ydata, marker='D', c='r')
ブランチドアーモンド色の線グラフを描画する	plt.plot(データ列, データ列2, color='blanchedalmond')
ピアソン相関係数でデータフレームの列と列の相関行列を求める	df[[column, column2]].corr(method='pearson')
リストとリストについて破線グラフを描画して、その色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
リストの各値を関数に適用した結果で並べ直す	sorted(aList, key=func)
データフレームのリストカラムの中に存在する文字列と文字列の合計を数える	df[aList].isin([value, value2]).sum()
ミントクリーム色のヒストグラムを描画する	plt.hist(データ列, color='mintcream')
データフレームを複数の列によって昇順に破壊的にソートする	df.sort_values(by=column, ascending=True, inplace=True)
パパイヤウィップ色の線グラフを描画する	plt.plot(データ列, データ列2, color='papayawhip')
数列とデータ列について散布図を描いて、マーカーの色を明るいに指定する	plt.plot(xdata, ydata, c='bright')
nとn2が等しい	n == n2
グラフの中の縦軸のラベルをuntitledに設定する	plt.ylabel(untitled)
数列と配列を折れ線グラフで描画する	plt.plot(xdata, ydata)
ヒストグラムを描画して、その色をライムグリーンに設定する	plt.hist(データ列, color='limegreen')
行列の行ごとの最大	np.max(aArray, axis=1)
本日が月曜日	datetime.datetime.today().weekday() == 0
オールドレース色の線グラフを描画する	plt.plot(データ列, データ列2, color='oldlace')
データフレームの中にとが存在する	df.isin([value, value2])
折れ線グラフの色をパレットトルコイズに設定する	plt.plot(データ列, データ列2, color='paleturquoise')
データフレームからカラムを三つ選択する	df[[column, column2, column3]]
データフレームのリストカラムのpercent分位数	df[aList].quantile(percent/100)
year年を日付時刻に変換する	datetime.datetime(year=year, month=1, day=1)
小数点数のルート	math.sqrt(x)
マッピングのキーと値を入れ替える	{v: k for k, v in aDict.items()}
データフレームを関数の値によってグループ化し、要約統計量を求める	df.groupby(関数).describe()
ヒストグラムを描画して、その色をゴールドに変更する	plt.hist(データ列, color='gold')
データフレームの列の中に文字列がある	df[col].isin([value])
浮動小数点数の最小値を求める	sys.float_info.min
散布図に赤いバツマーカーを使う	plt.plot(xdata, ydata, marker='x', c='r')
カラーコードの大バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='X', c=rgb)
タプルの要素を並べ変える	sorted(aTuple)
＜オプション＞色をゲインズボロに設定する	color = 'gainsboro'
ヒストグラムを描画して、色をアイボリーに設定する	plt.hist(データ列, color='ivory')
ペアリストpairsからカウンタを作る	collections.Counter(dict(pairs))
データフレームを使う	import pandas as pd
文字列中にひとつでも非数字がある	any(not c.isdigit() for c in s)
折れ線グラフの色をリネンに設定する	plt.plot(データ列, データ列2, color='linen')
リストとリストのカラーコードの明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
＜オプション＞グラフの色をダークグリーンに設定する	color = 'darkgreen'
ヒストグラムを描画して、その色をライトグレーに設定する	plt.hist(データ列, color='lightgrey')
CSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep=',')
データフレームの指定した列を抽出する	df[column]
カラーコードの星マーカーをリストとリストの散布図にプロットする	plt.plot(xdata, ydata, marker='*', c=rgb)
タプルの平均	sum(aTuple)/len(aTuple)
ライトスレイグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightslategrey')
データ列の曜日数を使う	ds.dt.dayofweek
折れ線グラフを描画して、その色をブラックに設定する	plt.plot(データ列, データ列2, color='black')
データフレームを1000の位で丸めて、整数型にする	df.round(-3).astype(int)
列を用いてによって降順にデータフレームをソートする	df.sort_values(by=column, ascending=False)
黒い大バツマーカーを散布図に使う	plt.plot(xdata, ydata, marker='X', c='k')
スクリプトファイルのパス	os.path.abspath(__file__)
＜オプション＞グラフの色をミディアムアクアマリンに設定する	color = 'mediumaquamarine'
＜オプション＞グラフの色をミッドナイトブルーに設定する	color = 'midnightblue'
リストとイテラブルについて散布図を描画して、四角マーカーの色をカラーコードに変更する	plt.plot(xdata, ydata, marker='s', c=rgb)
データフレームとデータ列を横方向に合体させる	pd.concat([df, ds], axis=1)
データフレームの列の文字列を欠損値にする	df[col].replace(s, np.nan)
ファイル全体をリストに変換する	[s.strip() for s in f.readlines()]
nがn2よりも大きいか調べる	n > n2
両端キューのstart〜endの部分要素	collections.deque(itertools.islice(deq, start, end))
タプルは少なくともひとつ真かどうか調べる	any(aTuple)
散布図のマーカーの大きさをnに設定する	plt.scatter(xdata, ydata, s=n)
ヒストグラムを描画して、その色をミディアムアクアマリンに設定する	plt.hist(データ列, color='mediumaquamarine')
線グラフを描画してその色をミディアムブルーに設定する	plt.plot(データ列, データ列2, color='mediumblue')
実数が無限大か調べる	math.isinf(x)
文字列を最後の部分文字列で分けたときの残りの文字列	s.rpartition(sub)[-1]
xの小数点以下'2'桁まで出力する	print(':.2f'.format(x))
データフレームの歪度を計算する	df.kurt()
行列の演算をする	import numpy as np
有理数を分母の最大値を指定して近似する	q.limit_denominator(max_denominator=1000000)
マッピングの値として要素は含まれているか調べる	element in aDict.values()
散布図にカラーコードの大バツマーカーを使う	plt.plot(xdata, ydata, marker='X', c=rgb)
線グラフの色をフクシアに変更する	plt.plot(データ列, データ列2, color='fuchsia')
データフレームのリストカラムの最頻値を計算する	df[aList].mode()
＜オプション＞欠損値も含める	dropna = True
データフレームの列の欠損値を直後の値で補う	df[col].fillna(method='bfill')
整数最小公倍数を計算する	math.lcm(n, n2)
データフレームを複数の列の値によってグループ化して、列挙する	[(name, group) for name, group in df.groupby(columns)]
データフレームを二つの列によってソートし、、更新する	df.sort_values(by=['A', 'B'], inplace=True)
辞書を浅くコピーする	dict(aDict)
折れ線の線幅をnに指定する	plt.plot(xdata, ydata, linewidth=n)
モジュールを検索するパスにディレクトリを追加する	sys.path.append(dir)
リストとリストについての散布図にカラーコードの三角マーカーを描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
イテラブルのそれぞれを関数でフィルタする	filter(func, iterable)
UNIXコマンドtextを実行する	os.system(text)
表データを二つの列によって昇順に整列して、更新する	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
試しに何か動かす	print('Hello World')
ヒストグラムを描画して、その色をダークスレートブルーに設定する	plt.hist(データ列, color='darkslateblue')
文字列を走査し、正規表現にASCII限定としてマッチするか見る	re.search(pattern, s, flags=re.ASCI)
折れ線グラフを描画して、色をシルバーに設定する	plt.plot(データ列, データ列2, color='silver')
数値を黒色でプリントできる文字列にする	f'\033[30m{value}\033[0m'
データフレームから列を1つ選択する	df[[column]]
エクセルデータファイルからnとn2のシートを読み込む	pd.read_excel(filename, sheet_name=[n, n2])
本日を文字列を使ってフォーマットする	"datetime.datetime.today().strftime(""%d/%m/%y"")"
データ列の未入力値を直前の値にセットする	ds.fillna(method='ffill')
標準入力から1行改行なしに読む	sys.stdin.readline().rstrip()
タプルの各要素を関数に適用した結果でソートする	sorted(aTuple, key=func)
区間数をnに設定してヒストグラムを描く	plt.hist(データ列, bins=n)
ライトスカイブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightskyblue')
折れ線グラフに線幅nの左三角印を描画する	plt.plot(データ列, データ列2, marker='<', markeredgewidth=n)
ヒストグラムの色をミディアムシアグリーンに設定する	plt.hist(データ列, color='mediumseagreen')
nがn2以下、それかn3以上か調べる	n <= n2 or n >= n3
＜オプション＞ダークオーキッドに色を設定する	color = 'darkorchid'
実数の二乗	x ** 2
日付と時間からタイムスタンプ	datetime.datetime(年, 月, 日, 時, 分, 秒)
日付データからn秒を減算する	aDate - datetime.timedelta(seconds=n)
＜オプション＞ダイアモンドマーカーを使う	marker = 'D'
未初期化の行列	np.empty((行数, 列数), dtype=np.int)
文字列の開始位置番目と終了位置番目の間に部分文字列が含まれない	s.find(sub, start, end) == -1
＜オプション＞ダークグリーンに色を設定する	color = 'darkgreen'
＜オプション＞フローラルホワイト色を使う	color = 'floralwhite'
nが一桁の整数	0 <= n <= 9
＜オプション＞暗い赤を用いる	color = 'darkred'
折れ線グラフに緑色のバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='g')
ビン数nのヒストグラムを描画する	plt.hist(データ列, bins=n)
データフレームの指定された列を配列として抽出する	df[column].values
ヒストグラムの色をライムに設定する	plt.hist(データ列, color='lime')
PandasでUNIX秒の文字列から日付データに変換する	pd.to_datetime(s, unit='s', utc=True)
文字列内にひとつでも数字が含まれるか調べる	any(c.isdigit() for c in s)
パステル調のグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
実数を実数で	x // y
＜オプション＞色をグリーンに設定する	color = 'green'
データ列の中に文字列とが含まれるかどうか調べる	ds.isin([value, value2])
ブランチドアーモンドにヒストグラムの色をセットする	plt.hist(データ列, color='blanchedalmond')
ファイルをバイナリ書き込み用にオープンして]、fとする	f = open(filepath, mode='wb')
黒い下三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='v', c='k')
実数に実数を加える	x + y
線グラフを描画して色をペルーに設定する	plt.plot(データ列, データ列2, color='peru')
文字列中に非アスキー文字がある	any(not c.isascii() for c in s)
文字列の中の正規表現による全てのマッチを使う	re.findall(pattern, s)
空白によって文字列を区切って、整数リストに変換する	map(int, s.split())
リストをナンバリングする	enumerate(aList)
nをn2だけ増加させる	n += n2
まとめてデータフレームの値をValueMapで変更する	df.replace(ValueMap)
ユーザが整数を入力する	int(input())
折れ線グラフの色をオレンジに設定する	plt.plot(データ列, データ列2, color='orange')
ヒストグラムを描画して、その色をアクアに変更する	plt.hist(データ列, color='aqua')
＜オプション＞グラフの色をダークターコイズに設定する	color = 'darkturquoise'
データフレームを各列と列の組み合わせ毎にグループ化して、平均値を求める	df.groupby([column, column2], as_index=False).mean()
日付データと日付データの時間差を秒で計算する	(aDate - aDate2).total_seconds()//60
配列とリストの青い濃いを描画する	plt.plot(xdata, ydata, linestyle='deep', color='b')
アンティークホワイトにヒストグラムの色を設定する	plt.hist(データ列, color='antiquewhite')
＜オプション＞淡い茶色色を用いる	color = 'tan'
データ列のNaNを最頻値で埋める	ds.fillna(ds.mode().iloc[0])
配列を転置する	aArray.T
線グラフを描画して、その色をロイヤルブルーに設定する	plt.plot(データ列, データ列2, color='royalblue')
データフレームをJSONLファイルにインデックスを付けずに保存する	df.to_csv(filename, index=None)
折れ線グラフに線幅nの右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markeredgewidth=n)
ヒストグラムを描画して、その色をオールドレースに設定する	plt.hist(データ列, color='oldlace')
日付データにn日分、加える	aDate + datetime.timedelta(days=n)
＜オプション＞レベッカパープル色を使う	color = 'rebeccapurple'
折れ線グラフの下三角マーカーを青くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
ファイルを追加できるようにオープンする]	open(filepath, mode='a')
空白文字を見る	' '
ヒストグラムの色をカデットブルーに設定する	plt.hist(データ列, color='cadetblue')
散布図に黒色の▼マーカーを用いる	plt.plot(xdata, ydata, marker='v', c='k')
リストと数列について散布図を描いて丸マーカーの色をカラーコードにセットする	plt.plot(xdata, ydata, marker='o', c=rgb)
JSONLファイルにエクセルファイルファイルでデータフレームを書き込む	df.to_excel(filename)
ダークシアグリーン色のヒストグラムを描画する	plt.hist(データ列, color='darkseagreen')
＜オプション＞赤を使う	color = 'red'
ヒストグラムを描画して、その色を紺碧に変更する	plt.hist(データ列, color='azure')
リストとリストについての散布図に赤いバツマーカーを描画する	plt.plot(xdata, ydata, marker='x', c='r')
ゼロ埋めされた符号なし８ビット整数型の行列	np.zeros(要素数, dtype=np.uint8)
タプルをひとつ飛ばしで抽出する	aTuple[::2]
日付時刻データををn時間後に進める	aDatetime + datetime.timedelta(hours=n)
文字列の先頭で正規表現に複数行対応としてマッチするか見る	re.match(pattern, s, flags=re.MULTILINE)
＜オプション＞コーラル色を使う	color = 'coral'
色差別ない色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='colorblind')
リストと配列の青い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
データフレームの列がxより小さい行を抽出する	df[df[column] < x]
ヒストグラムの透明度をxに変更する	plt.hist(データ列, alpha=x)
＜オプション＞書き込みモードに設定する	mode = 'w'
ライトグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightgrey')
画面用にグラフを指定する	sns.set(context='notebook')
ふたつの集合の差集合	aSet.difference(aSet2)
リストを青色でプリントする	print(f'\033[34m{value}\033[0m')
リストとリストで色差別ないグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
データフレームから型リストで指定されたデータ型の列を抽出する	df.select_dtypes(include=typeList)
リストとリストについての散布図に赤い下三角マーカーを描く	plt.plot(xdata, ydata, marker='v', c='r')
ふたつの関係がサブセットかどうか調べる	aSet.issubset(aSet2)
ヒストグラムを描画して、色をスノーに設定する	plt.hist(データ列, color='snow')
双方向キューのn番目に数値を挿入する	deq.insert(n, element)
折れ線グラフの上三角印を赤くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
データフレームを各列と列の組み合わせ毎に分類して、平均値を求める	df.groupby([column, column2], as_index=False).mean()
リストと配列についての散布図にポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.')
破線グラフの色を濃いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
折れ線グラフに黄色いバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='y')
折れ線グラフの色をカラーコードに変更する	plt.plot(xdata, ydata, color=rgb)
ヒストグラムを描画して、その色をロイヤルブルーにセットする	plt.hist(データ列, color='royalblue')
整数nを2進表現に変換する	bin(n)
三つのデータフレームを縦方向に連結する	pd.concat([df, df2, df3], axis=0)
startからendまでヒストグラムにする	plt.hist(データ列, range=(start, end))
折れ線グラフを描画して、その色をサーモンに設定する	plt.plot(データ列, データ列2, color='salmon')
点間のユークリッド距離を計算する	math.dist(point, point2)
データフレームを表示するとき、折り返しをオフに設定する	pd.set_option('expand_frame_repr', False)
日付時刻データが何年か知る	aDatetime.year
リストとイテラブルのカラーコードの暗いグラフを描く	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
△マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='^')
整数nを8進数表記にする	oct(n)
線グラフを描画して、その色を耐火レンガに指定する	plt.plot(データ列, データ列2, color='firebrick')
数式の微分を求める	sympy.diff(e)
デフォルトを適用する	sns.set()
セットの濃度を計算する	len(aSet)
濃いの折れ線の色をカラーコードに指定する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
折れ線グラフの右三角マーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='>', markeredgewidth=n)
＜オプション＞エンコーディングをUTF8に設定する	encoding = 'utf-8'
イテラブルを累積したイテラブル	itertools.accumulate(iterable, operator.mul)
データフレームのリストカラムの欠損値を最頻値で埋める	df[aList].fillna(df[aList].mode().iloc[0])
濃い色の折れ線グラフを描いて、その線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='deep')
代数計算を用いる	import sympy
淡い色の折れ線グラフをプロットして、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
データ列の未入力値を平均値に設定する	ds.fillna(ds.mean())
文字列が文字列より辞書順で前か	s < s2
データ列の欠損値を最頻値に設定する	ds.fillna(ds.mode().iloc[0])
データフレームを列によってグループ化して、個数を求める	df.groupby(column).count()
全要素を０で初期化された論理値型の行列	np.zeros(行数, 列数, dtype=np.int32)
インディゴ色のヒストグラムを描画する	plt.hist(データ列, color='indigo')
配列とリストの折れ線グラフをプロットしてuntitledとラベル付けする	plt.plot(xdata, ydata, label=untitled)
データフレームのリストカラムを1000の位で四捨五入して、整数型にする	df[aList].round(-3).astype(int)
＜オプション＞ダーク・スラテグレーにグラフの色を設定する	color = 'darkslategrey'
行列を転置する	aArray.T
＜オプション＞色をオーキッドに変更する	color = 'orchid'
データフレームをn行まで表示できるようにする	pd.set_option('display.max_rows', n)
ヒストグラムの色をパールゴールデンロッドにセットする	plt.hist(データ列, color='palegoldenrod')
上位集合か調べる	aSet.issuperset(aSet2)
データフレームから重複するデータを削除する	df.drop_duplicates()
＜オプション＞色を淡いピンク色にセットする	color = 'lightpink'
＜オプション＞グラフの色をロイヤルブルーに変更する	color = 'royalblue'
Pandasで、データフレームのcollを書式として日付データに変換する	pd.to_datetime(df[col], format='%Y-%m-%d')
マッピングのキーに対応した値	aDict.get(key)
タイムスタンプデータからn時間を減算する	aDatetime - datetime.timedelta(hours=n)
＜オプション＞サドルブラウン色を使う	color = 'saddlebrown'
辞書の値を列挙する	aDict.values()
文字列を最初の部分文字列で分割した場合の前半の文字列を取り出す	s.partition(sub)[0]
要素がセットに含まれないかどうか	element not in aSet
ダークサーモン色のヒストグラムを描画する	plt.hist(データ列, color='darksalmon')
ヒストグラムの描画して正規化する	plt.hist(データ列, density=True)
リストとリストで濃いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
グラフのカラーパレットを暗くする	sns.set(pallete='dark')
赤い四角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='s', c='r')
ファイルからフォルダ名を使う	os.path.dirname(filepath)
ビン数nでリストをビン分割して、namesのラベルをつける	pd.cut(aList, n, labels=names)
新しい文字列を使って文字列を全て置き換える	s.replace(sub, newsub)
データフレームの列のどの値が頻出か見る	df[col].mode()
折れ線グラフの色をサドルブラウンに指定する	plt.plot(データ列, データ列2, color='saddlebrown')
ミディアムパープルにヒストグラムの色を設定する	plt.hist(データ列, color='mediumpurple')
データフレームを二つの列の値によってグループ化し、要約統計量を求める	df.groupby(['A', 'B']).describe()
＜オプション＞アクアマリンにグラフの色を設定する	color = 'aquamarine'
折れ線グラフを描画して、その色をシスルに指定する	plt.plot(データ列, データ列2, color='thistle')
ヒストグラムの色をイエローグリーンに設定する	plt.hist(データ列, color='yellowgreen')
＜オプション＞ダークオーキッド色を使う	color = 'darkorchid'
ファイルのファイル名	os.path.basename(filepath)
明るいグラフをリストとデータ列でプロットして、線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color='r')
データ列を折れ線グラフに描画して、印を三角にする	plt.plot(データ列, データ列2, marker='^')
n2分のn	n / n2
Pandasで、フォーマットfmtで文字列を日付データに変換する	pd.to_datetime(s, format=fmt)
データフレームを関数の値によって集約して、列挙する	[(name, group) for name, group in df.groupby(関数)]
青い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='b')
文字列内にひとつでも英数字があるか	any(c.isalnum() for c in s)
データフレームの下n行を抽出する	df.tail(n)
両端キューの先頭にイテラブルの各要素を入れる	deq.extendleft(iterable)
再帰の上限を上げる	sys.setrecursionlimit(1000000)
＜オプション＞グラフの色をミントクリームに設定する	color = 'mintcream'
ピアソンでデータフレームの相関行列	df.corr(method='pearson')
＜オプション＞ライトコーラル色を使う	color = 'lightcoral'
配列とデータ列の散布図を描画して、マーカーをポイントに設定する	plt.plot(xdata, ydata, marker='.')
実数のn乗の実数剰余を求める	pow(x, n, y)
日付を使う	import datetime
データフレームのカラムの歪度	df[col].kurt()
＜オプション＞グラフの色をブランチドアーモンドに設定する	color = 'blanchedalmond'
折れ線グラフに赤いダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='r')
ヒストグラムの色をシスルに設定する	plt.hist(データ列, color='thistle')
最大値・最小値の範囲で一様な乱数を生成する	random.uniform(最小値, 最大値)
文字列を走査し、パターンにマッチするか見る	re.search(pattern, s)
＜オプション＞グラフの色をゴールデンロッドにする	color = 'goldenrod'
スカイブルー色のヒストグラムを描画する	plt.hist(データ列, color='skyblue')
破壊的にデータフレームを2つの列によってによって並べ直す	df.sort_values(by=['A', 'B'], inplace=True)
折れ線グラフを描画して、色を淡いピンク色にセットする	plt.plot(データ列, データ列2, color='lightpink')
変数を緑色でプリントできる文字列に変換する	f'\033[32m{value}\033[0m'
折れ線グラフの色をダークオーキッドに設定する	plt.plot(データ列, データ列2, color='darkorchid')
＜オプション＞小麦色色を使う	color = 'wheat'
カラーマップとしてヒストグラムを描画する	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
日付データををn日後に進める	aDate + datetime.timedelta(days=n)
辞書に辞書の項目を更新する	aDict.update(aDict2)
折れ線グラフを描画して、色を黄色くする	plt.plot(データ列, データ列2, color='y')
データフレームを列によってまとめたグループ	df.groupby(column)
カウンタからゼロカウントを取り除く	+aCounter
配列とリストについて散布図を描画して、マーカーを星に指定する	plt.plot(xdata, ydata, marker='*')
度数分布図をプロットし、、半透明ににする	plt.hist(データ列, alpha=0.5)
配列の和を算出する	aArray + aArray2
配列をヒストグラムにする	plt.hist(aArray)
折れ線グラフのマーカーをダイアモンドにする	plt.plot(データ列, データ列2, marker='D')
＜オプション＞赤色を使う	color = 'red'
部分文字列が文字列の開始位置番目からと終了位置までの間に含まれないか調べる	s.find(sub, start, end) == -1
データフレームの相関行列ピアソン相関係数で	df.corr(method='pearson')
配列の分散を計算する	np.var(aArray)
＜オプション＞ミディアムシアグリーンを使用する	color = 'mediumseagreen'
データフレームを列でソートして上位n件を取り出す	df.sort_values(columns).head(n)
データフレームのカラムの年	df[col].dt.year
文字列内にひとつでもアルファベットが含まれるか調べる	any(c.isalpha() for c in s)
ファイルを絶対パスに変換する	os.path.abspath(filepath)
配列とデータ列についての散布図を重なりを見やすく淡い色で描画する	plt.plot(xdata, ydata, c='muted', alpha=0.5)
＜オプション＞グラフの色をライトブルーに変更する	color = 'lightblue'
文字列中の部分文字列を文字列に置き換える	s.replace(sub, newsub)
リストとデータ列について散布図を描画して、菱形マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='D', c=rgb)
ライトシアン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightcyan')
ヒストグラムを描画して、その色を青紫に変更する	plt.hist(データ列, color='violet')
＜オプション＞パレットトルコイズにグラフの色を設定する	color = 'paleturquoise'
データ列とリストについて黒い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='k')
データフレームの相関行列ケンドールで	df.corr(method='kendall')
現在の時間数	datetime.date.today().hour
配列の累積和	np.cumsum(aArray)
データフレームを降順に２つの列によってによってソートする	df.sort_values(by=['A', 'B'], ascending=False)
自然数の順列の総数	math.perm(n)
ファイルを追加できるようにEUCでオープンする]	open(filepath, mode='a', encoding='euc_jp')
辞書の浅いコピーを作る	aDict.copy()
折れ線グラフの色をライトシアンに設定する	plt.plot(データ列, データ列2, color='lightcyan')
ゴールド色のヒストグラムを描画する	plt.hist(データ列, color='gold')
散布図に黒色の▲マーカーを使う	plt.plot(xdata, ydata, marker='^', c='k')
線グラフを描画して、その色をバリーウッドに指定する	plt.plot(データ列, データ列2, color='burlywood')
＜オプション＞ロージーブラウンを使う	color = 'rosybrown'
データ列とリストについてパステル調の色の折れ線グラフを描画してその線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
イテラブルを両端キューに変換する	collections.deque(iterable)
データフレームを'A'列の値でグループ化し、要約統計量を計算する	df.groupby('A').describe()
線グラフを描画して、その色をダークバイオレットに設定する	plt.plot(データ列, データ列2, color='darkviolet')
出力ストリームから1文字、読む	f.read(1)
リストとイテラブルについての散布図にカラーコードの右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
赤い丸印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='r')
折れ線グラフを描画して、その色をフローラルホワイトに設定する	plt.plot(データ列, データ列2, color='floralwhite')
＜オプション＞データ型を指定する	dtype = np.uint8
＜オプション＞データ型を指定する	dtype = np.int32
線グラフを描画してその色をミッドナイトブルーに変更する	plt.plot(データ列, データ列2, color='midnightblue')
文字列が無限に繰り返す列	itertools.repeat(element)
データフレームのカラムを小数点以下n桁で丸める	df[col].round(n)
数列とリストの折れ線グラフをuntitledとラベル付けして描画する	plt.plot(xdata, ydata, label=untitled)
グラフのカラーパレットを全般的に色差別なくする	sns.set(pallete='colorblind')
黄色い左三角マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='y')
色差別ないグラフの線幅をnに指定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
データフレームを列の値を使ってグループ化して、各グループごとの件数を知る	df.groupby(column).size()
リストの最初のn要素を除く	aList[n:]
リストにリストを追加して拡張する	aList.extend(aList2)
散布図に赤いポイントマーカーを使う	plt.plot(xdata, ydata, marker='.', c='r')
ひとつでも非アルファベットが文字列中にあるかどうか判定する	any(not c.isalpha() for c in s)
折れ線グラフを描画して、その色をミディアムパープルに設定する	plt.plot(データ列, データ列2, color='mediumpurple')
＜オプション＞グラフの色をダークカーキに指定する	color = 'darkkhaki'
ヒストグラムを描画してその色を紺碧に指定する	plt.hist(データ列, color='azure')
日付データからn週間分、減算する	aDate - datetime.timedelta(weeks=n)
＜オプション＞グラフの色をダークバイオレットに変更する	color = 'darkviolet'
折れ線グラフに大きさnの下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markersize=n)
赤いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
ヒストグラムを描画して色をライトグレーに設定する	plt.hist(データ列, color='lightgrey')
ダークオレンジ色のヒストグラムを描画する	plt.hist(データ列, color='darkorange')
＜オプション＞ディムグレー色を使用する	color = 'dimgray'
＜オプション＞マーカーを左三角に変更する	marker = '<'
リストとリストについて散布図を描画して、マーカーの色を暗いに設定する	plt.plot(xdata, ydata, c='dark')
行列の列	aArray[:, 列番号]
データフレームのカラムの未入力値を最頻値に指定する	df[col].fillna(df[col].mode().iloc[0])
グラフにグリッド線を入れる	plt.grid(True)
＜オプション＞ダークオリーブグリーン色を使う	color = 'darkolivegreen'
データフレームの列概要	df.info()
＜オプション＞ライトグレー色を使う	color = 'lightgrey'
線グラフの色をブルーバイオレットに設定する	plt.plot(データ列, データ列2, color='blueviolet')
折れ線グラフに黒い左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='k')
リストとイテラブルのカラーコードの暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
ヒストグラムの色をビスクに設定する	plt.hist(データ列, color='bisque')
フクシア色の線グラフを描画する	plt.plot(データ列, データ列2, color='fuchsia')
バツマーカーで散布図を描く	plt.plot(xdata, ydata, marker='x')
データ列をカテゴリデータに変換する	ds.astype(object)
データフレームのカラムのNaNを前の値で補う	df[col].fillna(method='ffill')
ベクトルのユニークな要素とその個数	u, counts = np.unique(aArray, return_counts=True)
データ列のタイムゾーンを文字列に設定する	ds.tz_convert(s)
データフレームのデータ型リスト	df.dtypes
ゼロ埋めされた配列を作成する	np.zeros(要素数)
＜オプション＞グラフの色をデピンクに設定する	color = 'deeppink'
実数を十六進表記の文字列に変換する	x.hex()
標準出力を強制表示する	sys.stdout.flush()
ユニークな値を要素とする行列	np.unique(aArray)
グラフのカラーパレットを色差別なくする	sns.set(pallete='colorblind')
実線にヒストグラムの線のスタイルを設定する	plt.hist(データ列, linestyle='solid')
文字列を青色でプリントする	print(f'\033[34m{value}\033[0m')
オブジェクトはリストクラスか調べる	isinstance(obj, list)
破線グラフの色をパステル調のに設定する	plt.plot(xdata, ydata, linestyle='dash', color='pastel')
折れ線グラフに緑色の下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='g')
タイムスタンプデータの曜日を整数で使う	aDatetime.weekday()
ヒストグラムを描画して半透明ににする	plt.hist(データ列, alpha=0.5)
ファイルパスを読み込みモードとして開いて]、fとする	f = open(filepath, mode='r')
NULLに等しいもの	None
オブジェクトが数値か調べる	isinstance(obj, (int,float))
＜オプション＞右三角マーカーを使用する	marker = '>'
文字列を黄色でプリントする	print(f'\033[33m{value}\033[0m')
黒いポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.', c='k')
データフレームを'A'列と'B'列の値によってグループ化する	df.groupby(['A', 'B'])
青緑色の折れ線グラフを描画する	plt.plot(データ列, データ列2, color='teal')
文字列を白色でプリントできる文字列に変換する	f'\033[37m{value}\033[0m'
＜オプション＞貝殻を用いる	color = 'seashell'
赤いポイントマーカーをリストとイテラブルについての散布図に描く	plt.plot(xdata, ydata, marker='.', c='r')
整数の最大値	sys.maxsize
タブ区切りでデータフレームをJSONLファイルに保存する	df.to_csv(filename, sep='\t')
折れ線グラフに赤い菱形マーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='r')
ファイルを開いて]、追加ストリームを求める	open(filepath, mode='a')
ガンマ関数の値	math.gamma(x)
文字列は全て数値か	s.isnumeric()
配列の柱状グラフを描画する	plt.hist(aArray)
リストとリストについて破線グラフを描き、、その色をパステル調のに設定する	plt.plot(xdata, ydata, linestyle='dash', color='pastel')
データフレームのカラムの欠損値を最小値で埋める	df[col].fillna(df[col].min())
値を白色にする	f'\033[37m{value}\033[0m'
データフレームのカラムの中に文字列と文字列がいくつあるか数える	df[col].isin([value, value2]).sum()
折れ線グラフの色をアクアに設定する	plt.plot(データ列, データ列2, color='aqua')
ヒストグラムの色をグレーに設定する	plt.hist(データ列, color='grey')
黒い明るいグラフをプロットする	plt.plot(xdata, ydata, linestyle='bright', color='k')
双方向キューをリストに変換する	list(deq)
グラフのパレットをパステル調にする	sns.set(pallete='pastel')
文字列を文字リストにする	list(s)
赤色の上三角マーカーで散布図を描く	plt.plot(xdata, ydata, marker='^', c='r')
グラフを全般的に暗くする	sns.set(pallete='dark')
データフレームをTSVから読み込む	pd.read_csv(filename, sep='\t')
＜オプション＞グラフの色をグリーンイエローに設定する	color = 'greenyellow'
実数の絶対値	math.fabs(x)
リストとリストについての散布図にカラーコードのダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c=rgb)
日付データの年数	aDate.year
＜オプション＞パールバイオレットレッドを使う	color = 'palevioletred'
文字列の先頭で正規表現にマッチするか見る	re.match(pattern, s)
黒いバツマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='x', c='k')
＜オプション＞グラフの色を濃いシアンに設定する	color = 'darkcyan'
イテラブルの変遷を折れ線グラフで描く	plt.plot(range(len(xdata)), xdata)
折れ線グラフのマーカーを星にする	plt.plot(データ列, データ列2, marker='*')
線グラフを描画してその色をブラックに設定する	plt.plot(データ列, データ列2, color='black')
データ列が正規分布からどの程度、尖っているか見る	ds.skew()
＜オプション＞グラフの色をスラグレーにする	color = 'slategrey'
データフレームのカラムが何年か確認する	df[col].dt.year
オブジェクトのイテレータ	iter(obj)
線グラフを描画してその色をレモンシフォンに変更する	plt.plot(データ列, データ列2, color='lemonchiffon')
実数が負かどうか調べる	x < 0
日付時刻データををn秒後に進める	aDatetime + datetime.timedelta(seconds=n)
Pandasで、データ列をdatetime64型に変換し、データフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(ds))
日付データと日付データの時間差を秒数で算出する	(aDate - aDate2).total_seconds()
二つのデータフレームを縦方向に連結する	pd.concat([df, df2], axis=0)
データフレームを列の値によってグループ化して、最大値を求める	df.groupby(column).max()
文字列をコロンで区切って列挙する	s.split(':')
小数点数のコサインの逆数を求める	math.acos(x)
anemptystring	''
＜オプション＞大バツマーカーを使う	marker = 'X'
ユーザから入力される	int(input())
インディアンレッド色のヒストグラムを描画する	plt.hist(データ列, color='indianred')
データフレームを'A'列によって整列し、、NaNを先頭にする	df.sort_values(by='A', na_position='first')
折れ線グラフの左三角印を赤くする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='r')
配列と配列の黒い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='k')
オプションで、出力先を標準エラーに指定する	file = sys.stderr
日付時刻データの日	aDatetime.day
＜オプション＞色をリネンに設定する	color = 'linen'
プログラムを異常終了する	sys.exit(1)
ベクトルを元に全要素が1の配列	np.ones_like(aArray)
線グラフの色をアリスブルーに変更する	plt.plot(データ列, データ列2, color='aliceblue')
ヒストグラムを描画して、その色をコーンズシルクにセットする	plt.hist(データ列, color='cornsilk')
日付時刻データが日付時刻データより後ろ	aDatetime > aDatetime2
xを整数に変換する	int(x)
文字列の文字数	len(s)
オーキッド色のヒストグラムを描画する	plt.hist(データ列, color='orchid')
タプルをミュータブルにする	list(aTuple)
データフレームをTSVファイルから読み込む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
データ列の欠損値を中央値に設定する	ds.fillna(ds.median())
折れ線グラフに緑色の星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='g')
行列の累積和	np.cumsum(aArray)
グラフの色を濃くする	sns.set(pallete='deep')
辞書から多重集合を作成する	collections.Counter(aDict)
＜オプション＞グラフの色をパールゴールデンロッドに設定する	color = 'palegoldenrod'
列の各要素に対して、predicateFuncがtrueであれば、その要素を出力する	itertools.takewhile(predicateFunc, iterable)
文字列内にひとつでも小文字が含まれるか調べる	any(c.islower() for c in s)
＜オプション＞グラフの色を青に設定する	color = 'blue'
折れ線グラフの色をライトスチールブルーに指定する	plt.plot(データ列, データ列2, color='lightsteelblue')
＜オプション＞バイナリモードに設定する	mode = 'rb'
データフレームの中にいくつがあるか数える	df.isin([value]).sum()
＜オプション＞書き込み用に設定する	mode = 'w'
大文字・小文字を無視して正規表現をあらかじめコンパイルする	re.compile(pattern, flag=re.IGNORECASE)
折れ線グラフを描画して、その色をオレンジレッドにする	plt.plot(データ列, データ列2, color='orangered')
データフレームのリスト列の相関行列	df[aList].corr()
実数の双曲線余弦の逆数	math.acosh(x)
＜オプション＞カラムの名前をnamesに指定する	header = names
日付データが木曜日かどうか調べる	aDate.weekday() == 3
折れ線グラフのスタイルを一点鎖線に設定する	plt.plot(データ列, データ列2, linestyle='dashbot')
文字列の先頭でパターンにマッチするか確認する	re.match(pattern, s)
＜オプション＞ミッドナイトブルー色を使う	color = 'midnightblue'
データフレームを２つの列の値によって集計して、列挙する	[(name, group) for name, group in df.groupby(['A', 'B'])]
アリスブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='aliceblue')
＜オプション＞線種を実線に設定する	linestyle = 'solid'
グラフの色を全般的に色差別なくする	sns.set(pallete='colorblind')
数を実数で割って切り捨てる	x // y
グラフの中の縦軸のラベルをuntitledにセットする	plt.ylabel(untitled)
列の各データが何回出現するか確認する	ds.value_counts()
カウンタの要素のカウント	aCounter[element]
ファイルから追加ストリームをオープンして]、fとする	f = open(filepath, mode='a')
要素が集合に含まれないかテストする	element not in aSet
データ列をn個にビン分割してnamesのラベルをつける	pd.cut(ds, n, labels=names)
ヘッダー行を右寄せに設定する	pd.set_option('colheader_justify', 'right')
リストの全ての要素を空にする	aList.clear()
両端キュー中の値の数を数える	deq.count(element)
折れ線グラフを描画して、色をグリーンイエローに設定する	plt.plot(データ列, データ列2, color='greenyellow')
最後から空白で文字列を区切る	s.rsplit()
折れ線グラフのポイントマーカーの線幅をnに設定する	plt.plot(データ列, データ列2, marker='.', markeredgewidth=n)
線グラフの色をゲインズボロに設定する	plt.plot(データ列, データ列2, color='gainsboro')
折れ線グラフを描画して、その色をグレーに設定する	plt.plot(データ列, データ列2, color='gray')
アルファベットからひとつランダムに選ぶ	random.choice(string.ascii_uppercase)
日付時刻データが金曜日か調べる	aDatetime.weekday() == 4
リストとリストについての散布図に赤色の菱形マーカーをプロットする	plt.plot(xdata, ydata, marker='D', c='r')
実行環境がWindows	sys.platform.startswith('win32')
多重集合を作る	collections.Counter()
＜オプション＞バツマーカーを描画する	marker = 'x'
リストとリストについて散布図を描画して、マーカーの色を色差別ないに設定する	plt.plot(xdata, ydata, c='colorblind')
データフレームから重複を残さず、削除する	df.drop_duplicates(keep=False)
整数nを十六進文字列に変換する	hex(n)[2:]
ヒストグラムの色をピンクに設定する	plt.hist(データ列, color='pink')
カウンタからマッピングを引く	aCounter.subtract(aDict)
グラフで使うカラーパレットをpalleteNameで指定する	sns.set(pallete=palleteName)
リストと数列の黒い淡いグラフをプロットする	plt.plot(xdata, ydata, linestyle='muted', color='k')
データフレームとデータ列を横方向につなぐ	pd.concat([df, ds], axis=1)
パステル調のグラフをプロットし、その線幅をnに指定する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
＜オプション＞マーカーを大バツに変更する	marker = 'X'
文字列リストにイテラブルを変換してタブで結合する	'\t'.join(map(str, iterable))
折れ線グラフを描画して、その色をミディアムオーキッドに設定する	plt.plot(データ列, データ列2, color='mediumorchid')
データフレームのリストカラムを十の位で丸めて、整数にする	df[aList].round(-1).astype(int)
正規化されたヒストグラムを描画する	plt.hist(データ列, density=True)
データ列の分散	ds.var()
パールゴールデンロッド色のヒストグラムを描画する	plt.hist(データ列, color='palegoldenrod')
要素が全て初期値の配列	np.full(要素数, 初期値, dtype=np.int)
リストとリストについて散布図を描画して、マーカーをポイントに設定する	plt.plot(xdata, ydata, marker='.')
正規分布で疑似乱数を得る	random.normalvariate(mu=0.5, sigma=0.2)
＜オプション＞色をディムグレーに設定する	color = 'dimgrey'
折れ線グラフの色を茶色に設定する	plt.plot(データ列, データ列2, color='brown')
データフレームを表示するとき、表示できる最大行数を変更する	pd.set_option('display.max_rows', n)
シアンにヒストグラムの色を設定する	plt.hist(データ列, color='cyan')
折れ線グラフの色をチョコレートに設定する	plt.plot(データ列, データ列2, color='chocolate')
ヒストグラムを描画して色をダークマゼンタにセットする	plt.hist(データ列, color='darkmagenta')
ファイルを文字コードtextで開く]	open(filepath, encoding=text)
折れ線グラフを描画して、その色をダークスラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategray')
グラフにx=0の点線を付ける	plt.axvline(x=0, linestyle='dotted')
ファイルをSJISで書き込み用にオープンする]	open(filepath, mode='w', encoding='shift_jis')
ペルー色のヒストグラムを描画する	plt.hist(データ列, color='peru')
ヒストグラムを描画して、その色をロイヤルブルーに設定する	plt.hist(データ列, color='royalblue')
折れ線グラフの色をサンディーブラウンにする	plt.plot(データ列, データ列2, color='sandybrown')
ヒストグラムを描画して、その色をミディアムバイオレットレッドに設定する	plt.hist(データ列, color='mediumvioletred')
ヒストグラムを描画して色をシスルに変更する	plt.hist(データ列, color='thistle')
カウンタの項目を増やす	aCounter[element] += 1
文字列を部分文字列で分けた場合の後半の文字列	s.partition(sub)[-1]
データフレームのcollを日付データにする	pd.to_datetime(df[col])
文字列中にひとつでも非アルファベットが含まれるかどうか調べる	any(not c.isalpha() for c in s)
末尾の列をデータフレームから除く	df[df.columns[:-1]]
データフレームを表示するときn列までデータフレームを表示可能なようにする	pd.set_option('display.max_columns', n)
イテラブルを文字列リストに変換して、部分文字列で連結する	sub.join(map(str, iterable))
＜オプション＞マーカーを星に変更する	marker = '*'
パステル調のグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
文字列を最後の部分文字列で二分し後半の文字列を使う	s.rpartition(sub)[-1]
データ列と数列の色差別ないグラフを描いてその色を青色に設定する	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
オブジェクトのプロパティを削除する	delattr(obj, プロパティ名)
変数が無限大に近づくとき数値の極限値を算出する	sympy.limit(e, z, oo)
nが5の倍数か	n % 5 == 0
JSONフォーマットの文字列を読み込む	json.loads(jsonString)
データ列を四分位数ごとにビン分割する	pd.qcut(ds, 4)
＜オプション＞グラフの色をライトシアンに変更する	color = 'lightcyan'
実数の逆双曲線正接	math.atanh(x)
＜オプション＞色をオールドレースに指定する	color = 'oldlace'
エクセルファイルからデータフレームを読み込む	pd.read_excel(filename)
プロットのサイズを横width縦heightに変更する	plt.figure(figsize=(width, height))
＜オプション＞改行コードを動作環境依存に変更する	newline = None
＜オプション＞ブラック色を使用する	color = 'black'
辞書からキーの値か、もしくは要素を得る	aDict.get(key, element)
部分文字列を範囲を指定して探す	s.find(sub, start, end)
折れ線グラフの色を赤くする	plt.plot(データ列, データ列2, color='r')
部分文字列を文字列中から探す	s.find(sub)
３つの最小値を求める	min(x, y, z)
データフレームをカラムごとにグループ分けして、それぞれのグループの分散を求める	df.groupby(column).var()
折れ線グラフの色をシエナに設定する	plt.plot(データ列, データ列2, color='sienna')
データフレームのカラムを1000の位で丸めて、整数型にする	df[col].round(-3).astype(int)
タブ区切りのファイルを文字化けしないように読み込む	pd.read_csv(filename, encoding='shift_jis')
パステル調の色でリストとリストについての散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
リストとリストについて散布図を描いて、マーカーを星に設定する	plt.plot(xdata, ydata, marker='*')
グラフで用いるフォントを日本語表示に設定する	sns.set(font='IPAexGothic')
データフレームの列を最初のカテゴリーを除外してダミー変数に変換する	pd.get_dummies(df[column], drop_first=True)
ヒストグラムの色を黄緑に設定する	plt.hist(データ列, color='chartreuse')
バイトオーダを調べる	sys.byteorder
データ列の各データが何回出現するか見る	ds.value_counts()
現在処理中の例外を情報を調べる	sys.exc_info()
プロットの見栄えを良くする	import seaborn as sns
リストとデータ列を用いて色差別ないグラフを描いて、線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
データフレームのリストカラムの値をValueMapで一度に置き換える	df[aList].replace(ValueMap)
データフレームを表示するとき、表示可能な最大行数をnに増やす	pd.set_option('display.max_rows', n)
折れ線グラフを描画して、その色をベージュに設定する	plt.plot(データ列, データ列2, color='beige')
集合から別の集合を全て除く	aSet.difference_update(aSet2)
正規表現にマッチした文字列を新しい文字列で置き換える	re.sub(pattern, newsub, s)
正接の逆数	math.atan(x)
データフレームを列の値によってグループ化し要約統計量を計算する	df.groupby(column).describe()
３つのリストをプリントする	print(value, value2, value3)
配列とリストについての散布図を色差別ない色として重なりを見やすく描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
文字列を部分文字列で分けたときの前半の文字列	s.partition(sub)[0]
＜オプション＞グラフの色をターコイズに変更する	color = 'turquoise'
データフレームのカラムが何時か見る	df[col].dt.hour
要素が集合の要素かどうか調べる	element in aSet
データフレームのカラムのメディアン	df[col].median()
実数を万の位で丸める	round(x, -4)
二つの文字列は等しくないかどうか調べる	s != s2
列'A'と列'B'をキーとして２つのデータフレームを右結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
データフレームを列によってソートして、下位n件を取り出す	df.sort_values(columns).tail(n)
線幅nの右三角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='>', markeredgewidth=n)
ヒストグラムを描画して、その色を黄緑に変更する	plt.hist(データ列, color='chartreuse')
＜オプション＞スカイブルーを使う	color = 'skyblue'
データフレームの各次元のサイズを確認する	df.shape
四角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='s')
グラフの中に枠なしの凡例を入れる	plt.legend(frameon=False)
折れ線グラフに大きさnの丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markersize=n)
ヒストグラムを描画して、色をライトゴールドロディイエローに設定する	plt.hist(データ列, color='lightgoldenrodyellow')
ヒストグラムの色をサンディーブラウンに設定する	plt.hist(データ列, color='sandybrown')
＜オプション＞ダーク・スラテグレー色を使う	color = 'darkslategrey'
データフレームを'A'列によって降順に破壊的に並べる	df.sort_values(by='A', ascending=False, inplace=True)
ひとつでも非大文字が文字列中にある	any(not c.isupper() for c in s)
整数nを8進表記に変換する	oct(n)
実数を二乗する	x ** 2
シアン色の線グラフを描画する	plt.plot(データ列, データ列2, color='cyan')
円周率	math.pi
線グラフの色をダークスレートブルーに設定する	plt.plot(データ列, データ列2, color='darkslateblue')
インデックスによってデータフレームをソートする	df.sort_index()
二つのデータフレームを列をキーにして左ジョインする	pd.merge(df, df2, on=column, how='left')
配列のデータ型	aArray.dtype()
文字列が全て大文字	s.isupper()
整数nはセットのいづれかか調べる	n in aSet
TSVファイルからデータフレームを読む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
FIXME	np.linalg.eig(aArray)
3自然数の最大公約数を求める	math.gcd(n, n2, n3)
ヒストグラムの色をフローラルホワイトにセットする	plt.hist(データ列, color='floralwhite')
＜オプション＞青紫色を使う	color = 'violet'
折れ線グラフを描画して、色をライトスレイグレーに変更する	plt.plot(データ列, データ列2, color='lightslategrey')
ヒストグラムを半透明にする	plt.hist(データ列, alpha=0.5)
オブジェクトが論理値か調べる	isinstance(obj, bool)
ヒストグラムを描画して、その色をダークバイオレットに設定する	plt.hist(データ列, color='darkviolet')
nが3の倍数か調べる	n % 3 == 0
耐火レンガ色の線グラフを描画する	plt.plot(データ列, データ列2, color='firebrick')
データフレームを各列毎にグループ化して、列の平均値を求める	df.groupby(column)[column2].mean()
データフレームを各列と列の組み合わせ毎にグループ分けし、、標準偏差を求める	df.groupby([column, column2], as_index=False).std()
＜オプション＞バツマーカーを使う	marker = 'x'
折れ線グラフを描画して、色を濃いシアンに設定する	plt.plot(データ列, データ列2, color='darkcyan')
双方向キューは空か確認する	len(deq) == 0
スピアマン相関係数でデータフレームのリスト列の相関行列	df[aList].corr(method='spearman')
折れ線グラフを描画して色を耐火レンガに設定する	plt.plot(データ列, データ列2, color='firebrick')
パステル調のグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='pastel', color='r')
配列から重複を除いた配列を初期化する	np.unique(aArray)
ファイルを文字列の示すエンコーディングでオープンする]	open(filepath, encoding=s)
耐火レンガ色のヒストグラムを描画する	plt.hist(データ列, color='firebrick')
グラフに凡例を文字列と文字列と加える	plt.legend([s, s2])
要素ひとつの組を作る	(element,)
タプルの値の一覧	aDict.values()
線グラフの色をブラックに設定する	plt.plot(データ列, データ列2, color='black')
ヒストグラムの色をダークスレートブルーにセットする	plt.hist(データ列, color='darkslateblue')
表データを各列と列の組み合わせ毎にグループ化して、合計を計算する	df.groupby([column, column2], as_index=False).sum()
データフレームのリストカラムの値は欠損値か	df[aList].isna()
ヒストグラムを描画してその色をスラグレーに設定する	plt.hist(データ列, color='slategrey')
文字列の接頭辞から部分文字列を消す	s.removeprefix(sub)
赤色の線グラフを描画する	plt.plot(データ列, データ列2, color='red')
色差別ないグラフの色を青にする	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
既存のファイルパスをSJISを用いて追加できるように開く]	open(filepath, mode='a', encoding='shift_jis')
＜オプション＞ブラウンにグラフの色を変更する	color = 'brown'
整数nの八進文字列を求める	oct(n)[2:]
データフレームのカラムの文字列を未入力値に変換する	df[col].replace(s, np.nan)
線グラフの色をコーンフラワーブルーに設定する	plt.plot(データ列, データ列2, color='cornflowerblue')
自然数個からk個取り出したときの並べ方の総数	math.perm(n, k)
文字列から部分文字列を全て取り除く	s.replace(sub, '')
列を配列に変換する	np.array(iterable)
オレンジ色の線グラフを描画する	plt.plot(データ列, データ列2, color='orange')
ふたつの集合の積集合	aSet.intersection(aSet2)
データフレームの列がx以上かつx2未満の行を抽出する	df[(x <= df[column]) & (df[column] < x2)]
nをn2で割った結果を切り上げる	(n + n2 - 1) // n2
カラムの母標準偏差を求める	ds.std(ddof=0)
リストとリストについての散布図を明るい色で描画する	plt.plot(xdata, ydata, c='bright')
FIXME:カテゴリーデータを出現頻度順に並べる	df['A'].value_counts().sort_index().index
ヒストグラムを描画して、その色をライトスレイグレーに変更する	plt.hist(データ列, color='lightslategrey')
＜オプション＞32ビット整数型を使用する	dtype = np.int16
ラベンダーブラッシュ色の線グラフを描画する	plt.plot(データ列, データ列2, color='lavenderblush')
ヒストグラムの色をデピンクに変更する	plt.hist(データ列, color='deeppink')
表データの列とカラムのヒートマップを描画する	sns.heatmap(df[[column, column2]].corr())
＜オプション＞ラベンダーブラッシュを用いる	color = 'lavenderblush'
エクセルファイルからデータフレームを読む	pd.read_excel(filename)
緑色の三角マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='g')
タイムスタンプデータからn日分、減らす	aDatetime - datetime.timedelta(days=n)
折れ線グラフを描画してその色をパールゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='palegoldenrod')
データフレームを各列毎にグループ化して、列の標準偏差を算出する	df.groupby(column)[column2].std()
タブ	'\t'
折れ線グラフを描画してその色をラベンダーに変更する	plt.plot(データ列, データ列2, color='lavender')
データフレームの列の名前リスト	df.columns
データフレームの列の名前を列から文字列に付け直す	df.rename(columns={column: name})
ヒストグラムの区間を変更する	plt.hist(データ列, range=(start, end))
数式の展開を行う	sympy.expand(e)
データフレームを列の値によってグループ分けする	df.groupby(column)
タイムスタンプデータにn日を加算する	aDatetime + datetime.timedelta(days=n)
濃いグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
赤いバツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='x', c='r')
折れ線グラフを描画して、その色を青紫に設定する	plt.plot(データ列, データ列2, color='violet')
＜オプション＞色を紺に変更する	color = 'darkblue'
グラフの中のフォントをfontNameに設定する	sns.set(font=fontName)
明るい色の折れ線グラフを描き、、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
二つの浮動小数点数が十分に近いか調べる	math.isclose(x, x2)
＜オプション＞下三角マーカーを使う	marker = 'v'
グラフをスライド用に設定する	sns.set(context='talk')
＜オプション＞グラフの色をパレットトルコイズに設定する	color = 'paleturquoise'
濃いグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
＜オプション＞エラーを無視するように設定する	errors = 'ignore'
文字列中の大文字を小文字に変換する	s.lower()
配列の要素ごとの積	np.multiply(aArray, aArray2)
両端キューに値をエンキューする	deq.appendleft(element)
ヒストグラムを描画して、その色をミディアムシアグリーンに設定する	plt.hist(データ列, color='mediumseagreen')
配列とリストについて散布図を描画して色を明るいに設定する	plt.plot(xdata, ydata, c='bright')
データフレームのリスト列の中に日付データと日付データがいくつあるか数える	df[aList].isin([value, value2]).sum()
＜オプション＞色をダークシアグリーンに変更する	color = 'darkseagreen'
リストとリストの散布図に星マーカーを描画する	plt.plot(xdata, ydata, marker='*')
緑色の左三角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='g')
データフレームのカラムの月	df[col].dt.month
ホワイトスモーク色の線グラフを描画する	plt.plot(データ列, データ列2, color='whitesmoke')
二進対数を求める	math.log2(x)
文字列の開始位置から終了位置までの範囲で部分文字列をカウントする	s.count(sub, start, end)
Pandasでデータフレームのカラムをタイムスタンプ型に変換しデータフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(df[col]))
折れ線グラフを描画して、その色をスプリンググリーンに設定する	plt.plot(データ列, データ列2, color='springgreen')
浮動小数点数は無限大	math.isinf(x)
xの小数点以下'3'桁までプリントする	print(':.3f'.format(x))
文字列をゼロ埋めする	s.zfill(文字列幅)
文字列の中で正規表現にマッチしたすべての文字列をリストにする	re.findall(pattern, s)
折れ線グラフを描画して、その色をライトグリーンに設定する	plt.plot(データ列, データ列2, color='lightgreen')
データフレームのリスト列の値を正規表現patternで一度にreplに変更する	df[aList].replace(pattern, repl, regex=True)
二つのデータフレームを横方向に一つにする	pd.merge(df, df2)
折れ線グラフの三角印のサイズをnに設定する	plt.plot(データ列, データ列2, marker='^', markersize=n)
カウンタ間でユニオン演算する	aCounter | aCounter2
nの三乗を求める	n ** 3
実数の双曲線余弦	math.cosh(x)
折れ線グラフを描画して、その色をロージーブラウンに設定する	plt.plot(データ列, データ列2, color='rosybrown')
明日の日付	datetime.date.today() + datetime.timedelta(days=1)
リストとリストについて散布図を描画して、マーカーを下三角に設定する	plt.plot(xdata, ydata, marker='v')
ヒストグラムの色をオーキッドに指定する	plt.hist(データ列, color='orchid')
データフレームを'A'列と'B'列によって整列し、、NaNを先頭にする	df.sort_values(by=['A', 'B'], na_position='first')
ヒストグラムを描画して、その色をマゼンタにセットする	plt.hist(データ列, color='magenta')
データ列と配列の折れ線グラフを文字列の色でプロットする	plt.plot(xdata, ydata, color=s)
浮動小数点数の最大値を求める	sys.float_info.max
列'A'と列'B'をキーとして二つのデータフレームを左結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='left')
データフレームを各列毎に集約して、列の個数を計算する	df.groupby(column)[column2].count()
要素が集合のメンバーでないか調べる	element not in aSet
＜オプション＞パウダーブルーを使う	color = 'powderblue'
データ列が正規分布からどの程度、尖っているか確認する	ds.skew()
書式fmtでデータフレームのcollをdatetime64型に変換する	pd.to_datetime(df[col], format=fmt)
値を黒色にする	f'\033[30m{value}\033[0m'
実数の正接の逆数	math.atan(x)
折れ線グラフに青いダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='b')
＜オプション＞ブール型を用いる	dtype = np.int32
nマイナスn2	n - n2
文字列中にひとつでも非英数字が含まれるか調べる	any(not c.isalnum() for c in s)
線グラフを描画してその色をパープルに設定する	plt.plot(データ列, データ列2, color='purple')
n進文字列をバイト列にする	int(s, n).to_bytes(length=bytesize, byteorder='big')
リストと数列について濃いグラフを描いて、色を青にする	plt.plot(xdata, ydata, linestyle='deep', color='b')
配列のヒストグラムを描画する	plt.hist(aArray)
ふたつの集合が共通の要素を持たないか	aSet.isdisjoint(aSet2)
データ列が何年か見る	ds.dt.year
折れ線グラフに星マーカーを使う	plt.plot(データ列, データ列2, marker='*')
ライトスカイブルーにヒストグラムの色を変更する	plt.hist(データ列, color='lightskyblue')
折れ線グラフの色をゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='goldenrod')
＜オプション＞マーカーを下三角に変更する	marker = 'v'
データ列を折れ線グラフに描画して、マーカーを三角印にする	plt.plot(データ列, データ列2, marker='^')
文字列の左側から部分文字列を除く	s.lstrip(sub)
黒色の▽マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='v', c='k')
折れ線グラフに黒い左三角印を描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='k')
データフレームのリストカラムの中の欠損値の合計を数える	df[aList].isna().sum()
折れ線グラフを描画して、その色をライトブルーに設定する	plt.plot(データ列, データ列2, color='lightblue')
eの実数乗	math.exp(x)
データフレームから指定されたデータ型の列名の一覧	df.select_dtypes(型).columns
スラグレーにヒストグラムの色を指定する	plt.hist(データ列, color='slategray')
文字列の左側から空白を取り除く	s.lstrip(' ')
折れ線グラフを描画して、その色をマゼンタに設定する	plt.plot(データ列, データ列2, color='magenta')
パステル調のでリストについての柱状図をプロットする	plt.hist(xdata, color='pastel')
等間隔でn個にデータフレームの中の列をビニングして、namesのラベルをつける	pd.cut(df[col], n, labels=names)
青い色差別ないグラフを描く	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
ヒストグラムの色をマゼンタに設定する	plt.hist(データ列, color='magenta')
全般的に色調を暗くする	sns.set(pallete='dark')
破壊的にデータフレームのn行目を削除する	df.drop(n, axis=0, inplace=True)
辞書でカウンタを更新する	aCounter.update(aDict)
ヒストグラムを描画して、その色をゲインズボロに設定する	plt.hist(データ列, color='gainsboro')
ヒストグラムを描画して、その色をライトブルーに設定する	plt.hist(データ列, color='lightblue')
ヒストグラムを描画して、色を濃いシアンに変更する	plt.hist(データ列, color='darkcyan')
リストとリストの色差別ないグラフを描画し、、その色を黒にする	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
折れ線グラフを描画して色をスチールブルーに設定する	plt.plot(データ列, データ列2, color='steelblue')
セットを更新不能に変換する	frozenset(aSet)
＜オプション＞ASCII文字に限定する	flag = re.ASCII
十六進数字を全部使う	string.hexdigits
リストとリストについて淡いグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='muted', color='b')
シエナにヒストグラムの色を設定する	plt.hist(データ列, color='sienna')
＜オプション＞チョコレート色を使う	color = 'chocolate'
n2行n列の二次元リスト	[[0] * n for _ in range(n2)]
ヒストグラムを描画してその色をプラムにセットする	plt.hist(データ列, color='plum')
浮動小数点数を複素数にする	complex(x)
＜オプション＞茶色色を使う	color = 'brown'
折れ線グラフに赤い丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='r')
ライトスレイグレー色のヒストグラムを描画する	plt.hist(データ列, color='lightslategrey')
折れ線グラフを描画して、その色をラベンダーに設定する	plt.plot(データ列, データ列2, color='lavender')
暗いの色を青にする	plt.plot(xdata, ydata, linestyle='dark', color='b')
実数の整数部	math.modf(x)[1]
ミディアムパープル色のヒストグラムを描画する	plt.hist(データ列, color='mediumpurple')
マップの項目名一覧	list(aDict)
＜オプション＞星マーカーを加える	marker = '*'
タイムスタンプデータが日曜日か調べる	aDatetime.weekday() == 6
点線でヒストグラムを描画する	plt.hist(データ列, linestyle='dotted')
＜オプション＞グラフの種類を実線に設定する	linestyle = 'solid'
ヒストグラムの色をライトサーモンにする	plt.hist(データ列, color='lightsalmon')
文字列の左側からタブを除去する	s.lstrip('\t')
折れ線グラフを描画して色をブランチドアーモンドに設定する	plt.plot(データ列, データ列2, color='blanchedalmond')
データ列は何曜日か見る	ds.dt.weekday_name
dateStringをdatetime64型に変換する	pd.to_datetime(dateString)
要素ひとつのタプル	(element,)
折れ線グラフにサイズnのポイント印を描画する	plt.plot(データ列, データ列2, marker='.', markersize=n)
本日の月数	datetime.datetime.today().month
折れ線グラフの印を四角にする	plt.plot(データ列, データ列2, marker='s')
日付データをn日前に戻す	aDate - datetime.timedelta(days=n)
折れ線グラフにポイントマーカーを使う	plt.plot(データ列, データ列2, marker='.')
オブジェクトにプロパティが存在するかどうか調べる	hasattr(obj, プロパティ名)
＜オプション＞グラフの色をオリベドラブに設定する	color = 'olivedrab'
Pandasで、フォーマットfmtを使ってデータ列をタイムスタンプにする	pd.to_datetime(ds, format=fmt)
データフレームのリストカラムの25パーセンタイル	df[aList].quantile(0.25)
データ列とラベルを指定して、縦棒をプロットする	plt.bar(ラベル列, データ列)
ヒストグラムの色をライトコーラルに設定する	plt.hist(データ列, color='lightcoral')
折れ線グラフに青い左三角印を描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='b')
ホットピンク色のヒストグラムを描画する	plt.hist(データ列, color='hotpink')
実数に浮動小数点数を掛ける	x * y
オレンジレッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='orangered')
データフレームの中の欠損値がある行を削除する	df.dropna()
分子と分母から有理数を作る	fractions.Fraction(分子, 分母)
数値を簡単化する	sympy.sympify(e)
カラーコードの星マーカーをリストとリストの散布図に描画する	plt.plot(xdata, ydata, marker='*', c=rgb)
ダークゴールデンロッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkgoldenrod')
折れ線グラフの色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgrey')
ファイルを文字コードtextでオープンする]	open(filepath, encoding=text)
データフレームを関数の値によってグループ化して、列挙する	[(name, group) for name, group in df.groupby(関数)]
サブ型か調べる	issubclass(サブクラス, クラス)
二つの文字列を順にプリントする	print(value, value2)
グラフの描画で暗い色テーマを用いる	sns.set(pallete='dark')
文字列中の小文字を大文字に変換する	s.upper()
折れ線グラフを描画して、その色をブランチドアーモンドに設定する	plt.plot(データ列, データ列2, color='blanchedalmond')
マッピングから項目名の値かもしくは要素を得る	aDict.get(key, element)
データフレームを複数の列の値でグループ化して、列挙する	[(name, group) for name, group in df.groupby(columns)]
折れ線グラフのスタイルを点線に設定する	plt.plot(データ列, データ列2, linestyle='dotted')
折れ線グラフのポイントマーカーを緑色にする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='g')
文字列をコロンで分割して文字列リストに変換する	s.split(':')
等量でn個にデータフレームの中の列をビン分割する	pd.qcut(df[col], n)
全要素を0で初期化された配列	np.zeros(要素数)
データ列の欠損値を平均値で埋める	ds.fillna(ds.mean())
列をキーとして2つのデータフレームを全結合する	pd.merge(df, df2, on=column, how='outer')
名前付きタプルをパラメータからインスタンス化する	C._make(パラメータ)
ヒストグラムを描画して、その色を紺碧に設定する	plt.hist(データ列, color='azure')
データフレームの指定した２列を抽出する	df[[column, column2]]
折れ線グラフを描画して、その色をオリベドラブに設定する	plt.plot(データ列, データ列2, color='olivedrab')
数式をパラメータについて微分する	sympy.diff(e, z)
折れ線グラフを描画してその色をアンティークホワイトに設定する	plt.plot(データ列, データ列2, color='antiquewhite')
日付データをISO形式の文字列に変換する	aDate.isoformat()
要素が集合のメンバーかどうか調べる	element in aSet
データフレームの列の中に文字列とがいくつ存在するかカウントする	df[col].isin([value, value2]).sum()
数式の変数を数式で置き換える	e.subs(z, e2)
辞書からキーの値をエラーなく得る	aDict.get(key, None)
グラフに格子線を入れる	plt.grid(True)
ヒストグラムを描画して、その色をペルーに設定する	plt.hist(データ列, color='peru')
分子n、分母mの有理数を用意する	fractions.Fraction(numerator=n, denominator=m)
辞書に項目名が存在するか	key in aDict
文字列を全て大文字に変換する	s.upper()
データ列を折れ線グラフに描画して、マーカーを▲にする	plt.plot(データ列, データ列2, marker='^')
配列を中央値でビン分割する	pd.qcut(aArray, 2)
＜オプション＞グラフの色をダークカーキに設定する	color = 'darkkhaki'
折れ線グラフのマーカーを右三角にする	plt.plot(データ列, データ列2, marker='>')
配列と数列で明るいグラフを描画して、その線幅をnに変更する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
二変数の最大値	max(x, y)
カラムの75パーセンタイル	ds.quantile(0.75)
真上位集合か調べる	aSet > aSet2
緑色で文字列を表示する	print(f'\033[32m{value}\033[0m')
ヒストグラムを描画してその色をブラックに設定する	plt.hist(データ列, color='black')
折れ線グラフを描画して、色を黄緑に変更する	plt.plot(データ列, データ列2, color='chartreuse')
xの絶対値を求める	abs(x)
本日をISO8601形式の文字列に変換する	datetime.datetime.today().isoformat()
折れ線グラフを描画して、その色を貝殻に設定する	plt.plot(データ列, データ列2, color='seashell')
リストとリストについての散布図に黒色の三角マーカーを描画する	plt.plot(xdata, ydata, marker='^', c='k')
ライムグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='limegreen')
イテラブルとイテラブルのカラーコードの淡いを描く	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
データフレームを２つの列の値によってグループ化する	df.groupby(['A', 'B'])
＜オプション＞８ビット整数型を使う	dtype = np.int8
リストとリストで明るいを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
カラーコードのポイントマーカーをリストとリストについての散布図に描く	plt.plot(xdata, ydata, marker='.', c=rgb)
リストとリストについて散布図を描画して、丸マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='o', c=rgb)
データフレームの列の各データが何回出現するか見る	df[col].value_counts()
配列のユニークな要素ごとの頻度	np.unique(aArray, return_counts=True)
タプルの値を並べる	sorted(aTuple)
折れ線グラフの色をダークカーキに指定する	plt.plot(データ列, データ列2, color='darkkhaki')
＜オプション＞グラフの色をミディアムシアグリーンに設定する	color = 'mediumseagreen'
リストとリストについてリストの値に応じて、散布図の色を変える	plt.scatter(xdata, ydata, c=aList, cmap='Blues')
変数について数値を積分する	sympy.integrate(e, z)
データフレームのカラムの欠損値をxで埋める	df[col].fillna(x)
赤いクロスマーカーを散布図に使う	plt.plot(xdata, ydata, marker='x', c='r')
リストと配列についての散布図を色差別ない色で描画する	plt.plot(xdata, ydata, c='colorblind')
シーグリーンにヒストグラムの色を指定する	plt.hist(データ列, color='seagreen')
ヒストグラムを描画して、その色をピンクに設定する	plt.hist(データ列, color='pink')
リストとリストについて散布図を描画して、マーカーを大バツに設定する	plt.plot(xdata, ydata, marker='X')
データフレームの列の値がxより大きくx2より小さい行を抽出する	df[(x < df[column]) & (df[column] < x2)]
文字列中の正規表現を新しい文字列で置き換える	re.sub(pattern, newsub, s)
緑色の下三角マーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='g')
データフレームのカラムの中の欠損値の合計を数える	df[col].isna().sum()
＜オプション＞インディアンレッド色を使う	color = 'indianred'
Pandasで、フォーマットでデータ列を日付データに変換する	pd.to_datetime(ds, format='%Y-%m-%d')
変数を太字にする	f'\033[1m{value}\033[0m'
折れ線グラフに描画して、印を下三角印にする	plt.plot(データ列, データ列2, marker='v')
＜オプション＞文字列を改行するの代わりに用いる	end = s
リストとイテラブルについての散布図に文字列という凡例用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
リストとデータ列の散布図を描画し、、上三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='^', c=rgb)
リストとデータ列について散布図をプロットして星マーカーの色をカラーコードに変更する	plt.plot(xdata, ydata, marker='*', c=rgb)
折れ線グラフを描画して、その色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgrey')
ヒストグラムを描画してその色をブランチドアーモンドに指定する	plt.hist(データ列, color='blanchedalmond')
データフレームを各列毎にグループ化して、文字列というグループの個数を求める	df.groupby(column).size()[s]
リストとリストについての散布図にカラーコードの右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
16進文字列をバイナリに変換する	int(s, 16).to_bytes(length=bytesize, byteorder='big')
文字列を青色でプリントできる文字列に変換する	f'\033[34m{value}\033[0m'
カウンタの上位を列挙する	aCounter.most_common(k)
線グラフを描画してその色をスノーに設定する	plt.plot(データ列, データ列2, color='snow')
＜オプション＞コーンズシルク色を使う	color = 'cornsilk'
濃いの折れ線グラフをデータ列と配列を用いてプロットして、線幅をnにする	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
文字列のの開始位置から終了位置までの間に部分文字列がいくつかあるか数える	s.count(sub, start, end)
両端キューの末尾に要素を追加する	deq.append(element)
データフレームの中で、列に重複があるか調べる	df.duplicated(subset=column)
＜オプション＞グラフの色をサドルブラウンに設定する	color = 'saddlebrown'
ふたつの集合が互いに素か調べる	aSet.isdisjoint(aSet2)
整数nの十六進表現	hex(n)
＜オプション＞グラフの色をライトグレーに設定する	color = 'lightgray'
データフレームのリストカラムの値を正規表現patternでまとめてreplに置き換える	df[aList].replace(pattern, repl, regex=True)
折れ線グラフを描画して、その色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgray')
リストを分割数nでビン分割する	pd.cut(aList, n)
八進数字を全て使う	string.octdigits
キューの最初に値を追加する	deq.appendleft(element)
ダイアモンドマーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='D')
データ列をビン数nでビン分割して、namesのラベルをつける	pd.cut(ds, n, labels=names)
カウンタの全数を使う	aCounter.total()
nからn2までのひとつ飛ばしの整数列	list(range(n, n2+1, 2))
折れ線グラフを描画して色をライトゴールドロディイエローに設定する	plt.plot(データ列, データ列2, color='lightgoldenrodyellow')
リストの値を小さい順にソートする	sorted(aList, reverse=False)
データフレームの列名を指定された列の名前一覧に置き換える	df.columns = columns
折れ線グラフの菱形マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='D', markersize=n)
ヒストグラムを描画して、色をダークターコイズに設定する	plt.hist(データ列, color='darkturquoise')
日付時刻データが日付時刻データより前か調べる	aDatetime < aDatetime2
折れ線グラフの色をスラグレーに設定する	plt.plot(データ列, データ列2, color='slategrey')
全要素を0で初期化された行列を作成する	np.zeros(要素数)
暗い色のマーカーを使って散布図をプロットする	plt.plot(xdata, ydata, c='dark')
ヒストグラムを描画して、その色をサーモンにする	plt.hist(データ列, color='salmon')
ヒストグラムを描画して色をフォレストグリーンに設定する	plt.hist(データ列, color='forestgreen')
＜オプション＞アリスブルーにグラフの色を変更する	color = 'aliceblue'
ヒストグラムを描画してその色をナバホホワイトに設定する	plt.hist(データ列, color='navajowhite')
暗い色で柱状グラフを描画する	plt.hist(xdata, color='dark')
ベクトルをベースに全要素が0の行列	np.zeros_like(aArray)
タイムスタンプデータの分	aDatetime.minute
オブジェクトは論理値型か調べる	isinstance(obj, bool)
文字列が文字列より辞書順で後か調べる	s > s2
折れ線グラフの色をディープスカイブルーに設定する	plt.plot(データ列, データ列2, color='deepskyblue')
日付時刻データをn分前にする	aDatetime - datetime.timedelta(minutes=n)
散布図にカラーコードのダイアモンドマーカーを使う	plt.plot(xdata, ydata, marker='D', c=rgb)
ハローワールドとプリントする	print('Hello World')
文字列の先頭	s[0]
ヒストグラムを描画して、その色を青緑に設定する	plt.hist(データ列, color='teal')
クラスは名前付きタプル	issubclass(C, tuple)
名前付きタプルを辞書に変換する	aNamedTupleObject._asdict()
データフレームの指定されたデータ型のカラム名を列挙する	df.select_dtypes(型).columns
＜オプション＞パウダーブルー色を使う	color = 'powderblue'
折れ線グラフでデータフレームのカラムとカラムを描画する	plt.plot(df[col], df[col2])
コマンドの第一引数	sys.argv[1]
グラフにx=0の一点鎖線を付ける	plt.axvline(x=0, linestyle='dashbot')
散布図に赤い下三角マーカーを使う	plt.plot(xdata, ydata, marker='v', c='r')
バツマーカーを散布図に使う	plt.plot(xdata, ydata, marker='x')
オールドレースにヒストグラムの色を設定する	plt.hist(データ列, color='oldlace')
三自然数の最小公倍数	math.lcm(n, n2, n3)
パウダーブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='powderblue')
ヒストグラムの色をマルーンに変更する	plt.hist(データ列, color='maroon')
データフレームの先頭n行	df.head(n)
＜オプション＞グレー色を使う	color = 'gray'
文字列の開始位置から終了位置まで部分文字列を探す	s.find(sub, start, end)
整数nを十六進リテラルに変換する	hex(n)
カラーコードの▲マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
シーケンスを累積する	itertools.accumulate(iterable, operator.mul)
グラフの用途を画面に設定する	sns.set(context='notebook')
マップのキー一覧	list(aDict)
＜オプション＞先頭のカラムをインデックスに設定する	index_col = 0
黒い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='k')
最適な位置に凡例を入れる	plt.legend(loc='best')
カラーコードの▼マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='v', c=rgb)
＜オプション＞小麦色色を用いる	color = 'wheat'
配列の列ごとの合計値	np.sum(aArray, axis=0)
配列をビン数nでビン分割する	pd.cut(aArray, n)
折れ線グラフを描画して、その色をターコイズにセットする	plt.plot(データ列, データ列2, color='turquoise')
＜オプション＞グラフの色をダークグレーに設定する	color = 'darkgray'
イテラブルとリストについて散布図をプロットして、色を淡いに設定する	plt.plot(xdata, ydata, c='muted')
青い明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color='b')
折れ線グラフの色をダークシアンに設定する	plt.plot(データ列, データ列2, color='darkcyan')
実数の自然対数	math.log(x)
折れ線グラフの色をロイヤルブルーに設定する	plt.plot(データ列, データ列2, color='royalblue')
線グラフを描画して、色をサーモンに変更する	plt.plot(データ列, データ列2, color='salmon')
ヒストグラムの色をスラグレーに設定する	plt.hist(データ列, color='slategrey')
リストとリストとして淡いを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
本日の曜日を整数で使う	datetime.datetime.today().weekday()
データフレームの指定された４つの列のみ抽出する	df[[column, column2, column3, column4]]
ヒストグラムを描画して、その色をスチールブルーに設定する	plt.hist(データ列, color='steelblue')
＜オプション＞貝殻に色を設定する	color = 'seashell'
本日をISO形式の文字列にする	datetime.datetime.today().isoformat()
xの絶対値	abs(x)
＜オプション＞ミディアムアクアマリン色を使う	color = 'mediumaquamarine'
黒いパステル調のを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='k')
組の先頭のn要素を取り除く	aTuple[n:]
列をキーにして２つのデータフレームを右ジョインする	pd.merge(df, df2, on=column, how='right')
折れ線グラフのバツマーカーを青くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='b')
Pythonパスの一覧	sys.path
2つのデータフレームを縦方向につなぐ	pd.concat([df, df2])
異なるカラムをキーにして２つのデータフレームを内部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
文字列がリストに含まれないか調べる	element not in aList
ファイルをバイナリできるようにオープンする]	open(filepath, mode='rb')
プラットフォームのコードポイントの最大値	sys.maxunicode
キュー中の数値のインデックス	deq.index(element)
折れ線グラフを描画して、色をゴールドに設定する	plt.plot(データ列, データ列2, color='gold')
Pandasで、データフレームのcollのエポック秒から日付データに変換する	pd.to_datetime(df[col], unit='s', utc=True)
折れ線グラフに描画して、印を左三角にする	plt.plot(データ列, データ列2, marker='<')
＜オプション＞オレンジを使う	color = 'orange'
配列間の要素ごとの最小公倍数を計算する	np.lcm(aArray, aArray2)
文字列を走査し、正規表現に大文字・小文字を無視してマッチするか見る	re.search(pattern, s, flags=re.IGNORECASE)
＜オプション＞グラフの色をフクシアに変更する	color = 'fuchsia'
組の合計値を求める	sum(aTuple)
空行をプリントする	print()
文字列が数字かどうか調べる	s.isdigit()
マップの項目名とその値を列挙する	aDict.items()
シーケンスにイテラブルを続ける	itertools.chain(iterable, iterable2)
データフレームのカラムとカラムを折れ線グラフで描画する	plt.plot(df[col], df[col2])
文字列中に漢字が使われているか調べる	re.search('[\u4E00-\u9FD0]', s)
黒いダイアモンドマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='D', c='k')
折れ線グラフを描画して、色を青緑に設定する	plt.plot(データ列, データ列2, color='teal')
グラフの背景色を暗くする	sns.set(style='darkgrid')
折れ線グラフの▲マーカーの線幅をnにセットする	plt.plot(データ列, データ列2, marker='^', markeredgewidth=n)
濃い色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='deep')
タイムスタンプデータが木曜日か調べる	aDatetime.weekday() == 3
折れ線グラフの丸マーカーを青くする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='b')
文字列の中でASCII限定として正規表現にマッチした全ての文字列をリストに変換する	re.findall(pattern, s, flags=re.ASCI)
折れ線グラフを描画してその色をゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='goldenrod')
全要素を1で初期化された行列	np.ones(行数, 列数, dtype=np.int)
データフレームのカテゴリデータをダミー変数にする	pd.get_dummies(df)
文字列を部分文字列で二分し、後半の文字列を使う	s.partition(sub)[-1]
折れ線グラフの右三角マーカーを黒色にする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='k')
データフレームのカラムの第三四分位数	df[col].quantile(0.75)
n2がnより大きく、かつ、n3未満	n < n2 and n2 < n3
文字列が平仮名か確認する	('ぁ' <= ch <= 'ん')
折れ線グラフを描画して色をブラウンに設定する	plt.plot(データ列, データ列2, color='brown')
ビスク色の線グラフを描画する	plt.plot(データ列, データ列2, color='bisque')
折れ線グラフを描画して、色をダークスラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategray')
＜オプション＞グラフの色をコーラルに設定する	color = 'coral'
リストとリストについての散布図に赤い▲マーカーを描画する	plt.plot(xdata, ydata, marker='^', c='r')
表データをインポートする	import pandas as pd
＜オプション＞グラフの色をライムグリーンにセットする	color = 'limegreen'
数列とイテラブルについてリストの値に応じて散布図の色を変える	plt.scatter(xdata, ydata, c=aList, cmap='Blues')
データフレームを'A'列と'B'列の値によってまとめたグループ	df.groupby(['A', 'B'])
リストとリストの散布図を濃い色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
変数をシアンでプリントできる文字列に変換する	f'\033[36m{value}\033[0m'
リストとリストについて散布図を描画して、右三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='>', c=rgb)
データフレームを1000の位で四捨五入して整数型にする	df.round(-3).astype(int)
リストを反転する	reversed(aList)
二つの文字列は等しくないか調べる	s != s2
nを半分にする	n /= 2
暗いグラフをリストと数列で描画して、線幅をnに変更する	plt.plot(xdata, ydata, linestyle='dark', color='r')
数列とリストについてカラーコードの淡いグラフをプロットする	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
タプルの値を関数に適用した結果で並べ変える	sorted(aTuple, key=func)
＜オプション＞グラフの色をシルバーに設定する	color = 'silver'
numpyを使う	import numpy as np
パステル調の色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='pastel')
nが-9以上、9以下か調べる	-9 <= n <= 9
日付時刻データををn週間後に進める	aDatetime + datetime.timedelta(weeks=n)
ブランチドアーモンド色のヒストグラムを描画する	plt.hist(データ列, color='blanchedalmond')
コーンフラワーブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='cornflowerblue')
折れ線グラフのスタイルを実線に指定する	plt.plot(データ列, データ列2, linestyle='solid')
アルファベットが文字列内に含まれるか調べる	any(c.isalpha() for c in s)
2つの変数をカンマで区切って表示する	print(value, value2, sep=',')
折れ線の線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n)
アンティークホワイト色のヒストグラムを描画する	plt.hist(データ列, color='antiquewhite')
データフレームの列を1000の位で丸める	df[col].round(-3)
二つの文字列をカンマで区切ってプリントする	print(value, value2, sep=',')
黒色の丸マーカーを散布図に使う	plt.plot(xdata, ydata, marker='o', c='k')
year年day月をタイムスタンプに変換する	datetime.datetime(year=year, month=month, day=1)
データフレームから列名を複数指定して選択する	df[columns]
折れ線グラフの丸マーカーを黄色にする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='y')
オプションで、ファイルを出力にする	file = sys.open(filename, 'w')
全要素を０で初期化された三二ビット整数型の行列	np.zeros(行数, 列数, dtype=np.int16)
リストと配列について散布図を描画してマーカーを左三角に設定する	plt.plot(xdata, ydata, marker='<')
折れ線グラフに黒い三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
真部分集合	aSet < aSet2
ValueMapでデータフレームのカラムの値をまとめて置き換える	df[col].replace(ValueMap)
数を複素数にする	complex(x)
ベクトルの行ごとの合計値	np.sum(aArray, axis=1)
フクシア色のヒストグラムを描画する	plt.hist(データ列, color='fuchsia')
明るいとしてリストについてのヒストグラムを描画する	plt.hist(xdata, color='bright')
変数を定義する	x = n
本日が金曜日かどうか	datetime.datetime.today().weekday() == 4
ケンドールでデータフレームの列と列の相関行列を算出する	df[[column, column2]].corr(method='kendall')
二つの文字列を改行で区切ってプリントする	print(value, value2, sep='\n')
numpyを使用する	import numpy as np
実数のn乗	x ** n
ブルーバイオレット色の線グラフを描画する	plt.plot(データ列, データ列2, color='blueviolet')
リストと配列の暗いグラフを描画して、色を青にする	plt.plot(xdata, ydata, linestyle='dark', color='b')
＜オプション＞ネイビーにグラフの色を指定する	color = 'navy'
文字列中の部分文字列を新しい文字列に回数を制限して置き換える	s.replace(sub, newsub, n)
エクセルファイルファイルからn番目のシートを読み込む	pd.read_excel(filename, sheet_name=n)
nとn2が等しいか確認する	n == n2
折れ線グラフを描画して、その色をバリーウッドに指定する	plt.plot(データ列, データ列2, color='burlywood')
線グラフの色をライトグレーに指定する	plt.plot(データ列, データ列2, color='lightgrey')
複素数型の全要素を０で初期化された行列	np.zeros(行数, 列数, dtype=bool)
二つの文字列をカンマで区切って表示する	print(value, value2, sep=',')
空の辞書	{}
２つのオブジェクトは等しいか調べる	obj == obj2
タプルの中の最大値	max(aTuple)
変数をスワップする	x, y = y, x
双方向キューの末尾に要素を入れる	deq.append(element)
カウンタをクリアする	aCounter.clear()
リストを四分位数ごとにビン分割する	pd.qcut(aList, 4)
横棒グラフを描画して、グラフ幅をxに設定する	plt.barh(ラベル列, データ列, width=x)
文字列を特殊文字も含め小文字に変換する	s.casefold()
ヒストグラムを描画して、その色をパレットトルコイズに変更する	plt.hist(データ列, color='paleturquoise')
線グラフの色をモカシンに変更する	plt.plot(データ列, データ列2, color='moccasin')
配列とイテラブルについて散布図を描画し、丸マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='o', c=rgb)
暗いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
重なりを見やすくリストとリストの散布図を濃い色で描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
データフレームをNaNを含めて列の値でグループ化する	df.groupby(column, dropna=False)
＜オプション＞セパレータをタブにする	sep = '\t'
ヒストグラムの色をレモンシフォンに設定する	plt.hist(データ列, color='lemonchiffon')
数を実数で割って、切り捨てる	x // y
実行時の標準出力の出力先がターミナルか調べる	os.isatty(sys.stdin.fileno())
文字列が文字列リストのいづれ	s in aStringList
数式を数値に変換する	float(e)
グラフの凡例の位置を(x,y)に設定する	plt.legend(loc=(x, y))
日付データをn分前に戻す	aDate - datetime.timedelta(minutes=n)
ダークグレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkgray')
リストとリストについて破線グラフを描画して、その色をパステル調のに設定する	plt.plot(xdata, ydata, linestyle='dash', color='pastel')
散布図に赤い大バツマーカーを使う	plt.plot(xdata, ydata, marker='X', c='r')
＜オプション＞左三角マーカーを使用する	marker = '<'
グラフの描画を綺麗にする	import seaborn as sns
データフレームの列と列に重複があれば、削除する	df.drop_duplicates(subset=[column, column2])
ライトグリーン色のヒストグラムを描画する	plt.hist(データ列, color='lightseagreen')
文字列内にひとつでも空白が含まれるか調べる	any(c.isspace() for c in s)
線グラフの色をネイビーに設定する	plt.plot(データ列, データ列2, color='navy')
黄緑にヒストグラムの色を変更する	plt.hist(データ列, color='chartreuse')
リストに文字列を追加する	aList.append(element)
カウンタの項目一覧を使う	aCounter.keys()
リストと配列について破線グラフを描画し、その色をパステル調のに設定する	plt.plot(xdata, ydata, linestyle='dash', color='pastel')
データフレームの列が文字列で始まらない行を選択する	df[not df[column].str.startswith(s)]
＜オプション＞ダークシアン色を使う	color = 'darkcyan'
ファイルの拡張子	os.path.splitext(filepath)[1].lstrip('.')
＜オプション＞シアン色を使用する	color = 'cyan'
＜オプション＞大バツマーカーを加える	marker = 'X'
配列の形状を変形する	aArray.reshape(行数, 列数)
リストとリストについての散布図を暗い色で描画する	plt.plot(xdata, ydata, c='dark')
濃いの線幅を指定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
折れ線グラフの色をピーチパフに設定する	plt.plot(データ列, データ列2, color='peachpuff')
イテラブルの重複コンビネーション	itertools.combinations_with_replacement(iterable, n)
データフレームのカラムのNaNを最小値で埋める	df[col].fillna(df[col].min())
文字列はタイトルケースかどうか調べる	s.istitle()
ファイルパスを書き込みできるように文字列の示す文字コードでオープンする]	open(filepath, mode='w', encoding=s)
日付時刻データの時間数	aDatetime.hour
＜オプション＞ダークバイオレットを使う	color = 'darkviolet'
＜オプション＞グラフの色をペールグリーンに設定する	color = 'palegreen'
部分文字列が文字列の終了位置以前に含まれないか調べる	s.find(sub, 0, end) == -1
２変数の最大値	max(x, y)
折れ線グラフを描画して、その色をダークシアンに設定する	plt.plot(データ列, データ列2, color='darkcyan')
要素が辞書の値として含まれているか調べる	element in aDict.values()
＜オプション＞サーモン色を用いる	color = 'salmon'
エラーを出力する	sys.stderr
日付時刻データの分数	aDatetime.minute
データフレームのカラムの中に存在する文字列の合計を数える	df[col].isin([value]).sum()
データフレームを表示するとき、ヘッダー行を右寄せに設定する	pd.set_option('colheader_justify', 'right')
データ列の中にいくつ日付データが存在するか数える	ds.isin([value]).sum()
赤色の四角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='s', c='r')
ヒストグラムを描画して、色をミディアムアクアマリンに設定する	plt.hist(データ列, color='mediumaquamarine')
最大長を指定して、両端キュー	collections.deque(maxlen=n)
二つのカラムを並べて箱ひげ図にする	plt.boxplot([df[column], df[column2]])
＜オプション＞ダークターコイズ色を使う	color = 'darkturquoise'
リストをビン数nでビン分割して、namesのラベルをつける	pd.cut(aList, n, labels=names)
データフレームを各列と列の組み合わせ毎にグループ分けして、最大値を計算する	df.groupby([column, column2], as_index=False).max()
ヒストグラムを描画してその色をスレートブルーに設定する	plt.hist(データ列, color='slateblue')
マップにキーがある	key not in aDict
オリーブ色の線グラフを描画する	plt.plot(データ列, データ列2, color='olive')
データフレームのリストカラムの文字列を欠損値に変換する	df[aList].replace(s, np.nan)
リストの長さ	len(aList)
文字列をASCII限定としてパターンで分割する	re.split(pattern, s, flags=re.ASCI)
nが-9以上、9以下かどうか調べる	-9 <= n <= 9
辞書のキーの一覧を得る	aDict.keys()
＜オプション＞グラフの色を茶色に変更する	color = 'brown'
ヒストグラムを描画して、その色をダークシアグリーンに設定する	plt.hist(データ列, color='darkseagreen')
ヒストグラムを描画して、色をスラグレーにセットする	plt.hist(データ列, color='slategrey')
データフレームを各列と列の組み合わせ毎にグループ化して、合計を求める	df.groupby([column, column2], as_index=False).sum()
ヒストグラムを描画して、その色をマルーンに設定する	plt.hist(データ列, color='maroon')
折れ線グラフを描画して、その色をアンティークホワイトにする	plt.plot(データ列, データ列2, color='antiquewhite')
データフレームを列によって昇順にソートする	df.sort_values(by=column, ascending=True)
TSVファイルからCSVファイルをSJISで読む	pd.read_csv(filename, encoding='shift_jis')
全ての十六進数字	string.hexdigits
列によってデータフレームをグループ化して、各グループごとの最大値を計算する	df.groupby(column).max()
配列と数列についての散布図にカラーコードのクロスマーカーを描画する	plt.plot(xdata, ydata, marker='x', c=rgb)
青紫色のヒストグラムを描画する	plt.hist(データ列, color='violet')
カウンタ同士で共通部分演算する	aCounter & aCounter2
＜オプション＞グラフの色をミディアムバイオレットレッドに設定する	color = 'mediumvioletred'
ヒストグラムを描画して、色をグリーンに変更する	plt.hist(データ列, color='green')
＜オプション＞ミディアムオーキッド色を使う	color = 'mediumorchid'
＜オプション＞ライトブルー色を使う	color = 'lightblue'
データ列は何日か確認する	ds.dt.day
バイナリ書き込みモードを用いてファイルを開く]	open(filepath, mode='wb')
データフレームの列の文字列が文字列で終わらない行を抽出する	df[not df[column].str.endswith(s)]
部分文字列が部分文字列で始まるかどうか調べる	s.startswith(sub)
データフレームを'A'列によって昇順にソートして、更新する	df.sort_values(by='A', ascending=True, inplace=True)
本日の日付時刻を使う	datetime.datetime.today()
折れ線グラフを描画して、その色をビスクに設定する	plt.plot(データ列, データ列2, color='bisque')
オブジェクトは集合か調べる	isinstance(obj, set)
二つの文字列をコロンで区切ってプリントする	print(value, value2, sep=':')
線グラフの色をミディアムシアグリーンに変更する	plt.plot(データ列, データ列2, color='mediumseagreen')
カラムを丸めて整数型にする	ds.round().astype(int)
値が集合に含まれるかどうか調べる	element in aSet
ヒストグラムの色をタンに設定する	plt.hist(データ列, color='tan')
nがn2未満、またはn3以上か	n < n2 or n >= n3
ヒストグラムの色を耐火レンガに設定する	plt.hist(データ列, color='firebrick')
ヒストグラムの色を淡い茶色に設定する	plt.hist(データ列, color='tan')
n回文字列が繰り返すイテラブルを求める	itertools.repeat(element, n)
リストと配列について散布図をプロットし、、色をパステル調のに設定する	plt.plot(xdata, ydata, c='pastel')
折れ線グラフの四角マーカーを黄色くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='y')
文字列の大文字と小文字を交換する	s.swapcase()
リストとリストについて濃い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='deep')
文字列リストをひとつの文字列にする	''.join(aStringList)
2つ並べてヒストグラムを描画する	plt.hist([データ列, データ列2], color=['b', 'r'])
3変数の最小値	min(x, y, z)
集合にイテラブルを追加更新する	aSet.update(iterable)
データフレームを複数の列によってによって破壊的にソートする	df.sort_values(by=column, inplace=True)
データ列の未入力値を最小値に指定する	ds.fillna(ds.min())
ヒストグラムの色をゴールドに指定する	plt.hist(データ列, color='gold')
実行を強制的に終了する	sys.exit()
シーケンスを集合にする	set(iterable)
データフレームを列でソートして、下の方を取り出す	df.sort_values(columns).tail(n)
カウンタからリストをカウントして引く	aCounter.subtract(iterable)
日付データの月数	aDate.month
カラーコードの左三角マーカーを散布図に使用する	plt.plot(xdata, ydata, marker='<', c=rgb)
データフレームのカラムの曜日数	df[col].dt.dayofweek
＜オプション＞改行コードを動作環境依存に設定する	newline = None
データフレームの列をインデックスに設定する	df.set_index(column)
折れ線グラフの色をパウダーブルーに変更する	plt.plot(データ列, データ列2, color='powderblue')
リストとリストで暗いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
表データから重複ありでランダムにn行をサンプリングする	df.sample(n, replace=True)
＜オプション＞最初の行をヘッダに設定する	header = 0
n進文字列をバイト列に変換する	int(s, n).to_bytes(length=bytesize, byteorder='big')
両端キューの先頭に要素を入れる	deq.appendleft(element)
＜オプション＞ダークオレンジ色を使う	color = 'darkorange'
ファイルをオープンして]、追加ストリームを使う	open(filepath, mode='a')
イテラブルとリストについての散布図に黒色の左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c='k')
文字列の終了位置より前に部分文字列が含まれるか調べる	s.find(sub, 0, end) != -1
データフレームのカラムのタイムゾーンを文字列に変更する	df[col].tz_convert(s)
イテラブルから双方向キューを生成する	collections.deque(iterable)
日付データが日付データと同時か調べる	aDate == aDate2
変数名を項目名として、辞書	dict(name=element)
配列と配列の散布図を描画してマーカーを△に指定する	plt.plot(xdata, ydata, marker='^')
ヒストグラムを描画して、その色をパールゴールデンロッドに設定する	plt.hist(データ列, color='palegoldenrod')
文字列の右端から空白を取り除く	s.rstrip(' ')
タプルのn番目以降の部分を取り出す	aTuple[n:]
ライトスレイグレー色のヒストグラムを描画する	plt.hist(データ列, color='lightslategray')
グラフの中のフォントをfontNameに変更する	sns.set(font=fontName)
データフレームから数値データの列のみ抽出する	df.select_dtypes('number')
線グラフを描画して、その色をフローラルホワイトに設定する	plt.plot(データ列, データ列2, color='floralwhite')
文字列を部分文字列で分けたときの後半の文字列	s.partition(sub)[-1]
データフレームをグループ化し、列に対し最小値を算出する	df.groupby(column)[column2].min()
折れ線グラフの▼マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='v', markersize=n)
折れ線グラフを描画してその色をロージーブラウンに設定する	plt.plot(データ列, データ列2, color='rosybrown')
ふたつの関係が下位集合かどうか調べる	aSet.issubset(aSet2)
線グラフを描画してその色をカーキに設定する	plt.plot(データ列, データ列2, color='khaki')
折れ線グラフを描画してその色をダークシアグリーンに設定する	plt.plot(データ列, データ列2, color='darkseagreen')
最大値・最小値で整数乱数を生成する	random.randint(最小値, 最大値)
イテラブルを累積する	itertools.accumulate(iterable, operator.mul)
＜オプション＞色をデピンクに指定する	color = 'deeppink'
＜オプション＞ディムグレーにグラフの色を指定する	color = 'dimgray'
折れ線グラフを描画して、その色をライトグレーにセットする	plt.plot(データ列, データ列2, color='lightgrey')
マッピングをチェーンマップにする	collections.ChainMap(aDict)
データフレームの列名を列挙する	df.columns
２つの列を並べて箱ひげ図にする	plt.boxplot([df[column], df[column2]])
整数nの十六進文字列	hex(n)[2:]
ヒストグラムの色をナバホホワイトにする	plt.hist(データ列, color='navajowhite')
本日の日数	datetime.datetime.today().day
ファイルパスをSJISで書き込み用にオープンする]	open(filepath, mode='w', encoding='shift_jis')
線グラフを描画して、その色をタンに設定する	plt.plot(データ列, データ列2, color='tan')
ライトグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightseagreen')
2つの浮動小数点数は近似値か判定する	math.isclose(x, x2)
ヒストグラムの色をローングリーンに設定する	plt.hist(データ列, color='lawngreen')
ヒストグラムを描画して、その色をグリーンイエローに設定する	plt.hist(データ列, color='greenyellow')
集合の浅いコピー	aSet.copy()
ベクトルの全要素の値を変更する	aArray[:, :] = 指定の値
列でデータフレームを分類し、、合計を求める	df.groupby(column).sum()
JSONファイルの入力を辞書に変換する	json.load(fin)
＜オプション＞色をミディアムオーキッドに変更する	color = 'mediumorchid'
折れ線グラフの上三角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='^', markersize=n)
Pandasで、フォーマットfmtで文字列を日付データにする	pd.to_datetime(s, format=fmt)
今日を文字列でフォーマットする	"datetime.datetime.today().strftime(""%d/%m/%y"")"
折れ線グラフの色をミントクリームに設定する	plt.plot(データ列, データ列2, color='mintcream')
イテラブルを累加したイテラブルを求める	itertools.accumulate(iterable)
折れ線グラフの色を白に設定する	plt.plot(データ列, データ列2, color='white')
データフレームを二つの列によってまとめたグループ	df.groupby(['A', 'B'])
データフレームのリストカラムの中に文字列があるか調べる	df[aList].isin([value])
文字を文字コードに変換する	ord(ch)
変数について数式を積分する	sympy.integrate(e, z)
透明度alphaでリストと配列の折れ線グラフを描画する	plt.plot(xdata, ydata, alpha=alpha)
データ列とリストの色差別ないグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
日付データにn分分、加算する	aDate + datetime.timedelta(minutes=n)
要素がセットに含まれるか調べる	element in aSet
文字列をASCII限定として正規表現で分ける	re.split(pattern, s, flags=re.ASCI)
ダークスレートブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkslateblue')
ダークオーキッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkorchid')
全要素を０で初期化した８ビット整数型の行列	np.zeros(行数, 列数, dtype=np.int8)
折れ線グラフの四角印を黄色くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='y')
データフレームのカラムの曜日が何日目か見る	df[col].dt.dayofweek
＜オプション＞グラフの色をインディゴに設定する	color = 'indigo'
＜オプション＞グラフの色をダークグレーに設定する	color = 'darkgrey'
線グラフを描画して、色をスラグレーに変更する	plt.plot(データ列, データ列2, color='slategray')
文字列を式として評価する	eval(s)
行列と同じ大きさの空の行列を作る	np.empty_like(aArray)
線グラフの色をラベンダーに設定する	plt.plot(データ列, データ列2, color='lavender')
ヒストグラムを描画して、その色をミッドナイトブルーに設定する	plt.hist(データ列, color='midnightblue')
データフレームのカラムの欠損値を最大値で埋める	df[col].fillna(df[col].max())
配列と配列についての散布図に丸マーカーをプロットする	plt.plot(xdata, ydata, marker='o')
集合の濃度	len(aSet)
データフレームとしてTSVファイルを読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
複数カラムの散布図を一度に描画する	sns.pairplot(df[[column, column2, column3]])
タイムスタンプデータがタイムスタンプデータと同時か調べる	aDatetime == aDatetime2
文字列中にひとつでも非アスキー文字が含まれるか調べる	any(not c.isascii() for c in s)
数列とリストについてリストの値に応じて散布図の色を変える	plt.scatter(xdata, ydata, c=aList, cmap='Blues')
折れ線グラフの色をスプリンググリーンに変更する	plt.plot(データ列, データ列2, color='springgreen')
折れ線グラフを描画して、その色をブルーバイオレットに設定する	plt.plot(データ列, データ列2, color='blueviolet')
折れ線グラフの色をダークマゼンタにする	plt.plot(データ列, データ列2, color='darkmagenta')
データフレームのリストカラムが正規分布からどの程度、尖っているか見る	df[aList].skew()
リストとデータ列の散布図を描画し、、四角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='s', c=rgb)
最大行数をnにする	pd.set_option('display.max_rows', n)
ヒストグラムを描画して、その色をダークグリーンに設定する	plt.hist(データ列, color='darkgreen')
折れ線グラフの色を貝殻に設定する	plt.plot(データ列, データ列2, color='seashell')
淡いグラフの色を青にする	plt.plot(xdata, ydata, linestyle='muted', color='b')
Pandasで、エポック秒のデータ列から日付データに変換する	pd.to_datetime(ds, unit='s', utc=True)
＜オプション＞△マーカーを使う	marker = '^'
データフレームのリスト列の文字列をNaNに変換する	df[aList].replace(s, np.nan)
ポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.')
データフレームを列によって昇順にソートして、更新する	df.sort_values(by=column, ascending=True, inplace=True)
日付時刻データの日付	aDatetime.date()
赤い暗いグラフを描く	plt.plot(xdata, ydata, linestyle='dark', color='r')
データ列の標準偏差	ds.std()
ヒストグラムを描画して、その色をバリーウッドに設定する	plt.hist(データ列, color='burlywood')
日付時刻データが何曜日か知る	aDatetime.weekday()
グラフにy=0の破線を設定する	plt.axhline(y=0, linestyle='dashed')
線グラフを描画して、その色をトマトに変更する	plt.plot(データ列, データ列2, color='tomato')
配列をビニングする	pd.cut(aArray, aList)
現在の再帰の最大回数	sys.getrecursionlimit()
明るい色をグラフの描画で使う	sns.set(pallete='bright')
折れ線グラフを描画して色を白に指定する	plt.plot(データ列, データ列2, color='white')
破線グラフの色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
データフレームのカラムの中にいくつ文字列が含まれるか数える	df[col].isin([value]).sum()
ヒストグラムをプロットしてビンの数をnに変更する	plt.hist(データ列, bins=n)
色差別ないグラフの線幅をnにする	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
ヒストグラムを描画して、色をローングリーンに変更する	plt.hist(データ列, color='lawngreen')
文字列を全て小文字に変換する	s.casefold()
ヒストグラムの色をコーンフラワーブルーに設定する	plt.hist(データ列, color='cornflowerblue')
＜オプション＞グラフの種類を点線にする	linestyle = 'dotted'
折れ線グラフを描画して、その色をゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='goldenrod')
データフレームをタブ区切りのファイルから読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
本日の日	datetime.datetime.today().day
ランタイムの再帰の最大回数	sys.getrecursionlimit()
代数計算を使う	import sympy
コマンドの第二引数を知る	sys.argv[1]
青い淡いグラフを描く	plt.plot(xdata, ydata, linestyle='muted', color='b')
データフレームの中の列を四分位数で分割する	pd.qcut(df[col], 4)
変数が0に近づくとき、数式の極限値を算出する	sympy.limit(e, z, 0)
データフレームのそれぞれのグループごとの分散	df.groupby(column).var()
散布図をポイントマーカーで描画する	plt.plot(xdata, ydata, marker='.')
ヒストグラムの色をスチールブルーに設定する	plt.hist(データ列, color='steelblue')
グラフの色を淡くする	sns.set(pallete='muted')
データフレームを各列毎にグループ化して、列の分散を求める	df.groupby(column)[column2].var()
ヒストグラムを描画して、その色をミントクリームに変更する	plt.hist(データ列, color='mintcream')
ヒストグラムの色をスレートブルーに設定する	plt.hist(データ列, color='slateblue')
xの小数点以下'1'桁までをプリントする	print(':.1f'.format(x))
黒色の濃いグラフを描く	plt.plot(xdata, ydata, linestyle='deep', color='k')
オブジェクトのプロパティの値を設定する	setattr(obj, プロパティ名, 値)
文字列が部分文字列で終わるかテストする	s.endswith(sub)
昨日の日付	datetime.date.today() - datetime.timedelta(days=1)
＜オプション＞線種を一点鎖線に設定する	linestyle = 'dashbot'
部分文字列か調べる	sub in s
データ列の分散を求める	ds.var()
リストとリストについての散布図に文字列という凡例用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
二つのデータフレームを異なるカラムをキーにして左ジョインする	pd.merge(df, df2, left_on=column, right_on=column2, how='left')
線グラフの色をネイビーにセットする	plt.plot(データ列, データ列2, color='navy')
最頻値でデータフレームのリスト列の欠損値を埋める	df[aList].fillna(df[aList].mode().iloc[0])
ヒストグラムの色をライトグリーンに設定する	plt.hist(データ列, color='lightgreen')
ダーク・スラテグレー色のヒストグラムを描画する	plt.hist(データ列, color='darkslategrey')
タプルの先頭	aTuple[0]
プログラムの実行を異常終了する	sys.exit(1)
日付時刻データにn週間分、加算する	aDatetime + datetime.timedelta(weeks=n)
折れ線グラフに大きさnのバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markersize=n)
TSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t')
暗いグラフの色を赤くする	plt.plot(xdata, ydata, linestyle='dark', color='r')
折れ線グラフの色を黄色に設定する	plt.plot(データ列, データ列2, color='yellow')
部分文字列が文字列中に存在しない	sub not in s
ミスティローズ色のヒストグラムを描画する	plt.hist(データ列, color='mistyrose')
＜オプション＞レベッカパープルを用いる	color = 'rebeccapurple'
ヒストグラムを描画して、その色をライトイエローに設定する	plt.hist(データ列, color='lightyellow')
実数の双曲線正弦	math.sinh(x)
折れ線グラフの色を耐火レンガに設定する	plt.plot(データ列, データ列2, color='firebrick')
データ列の欠損値を直前の値で補う	ds.fillna(method='ffill')
丸マーカーで散布図を描く	plt.plot(xdata, ydata, marker='o')
文字列を空白で区切って、文字列リストに変換する	s.split()
ヒストグラムを描画して、色をライトグリーンに変更する	plt.hist(データ列, color='lightgreen')
文字列中の部分文字列の出現をカウントする	s.count(sub)
濃いグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='deep', color='r')
データフレームの欠損値を直後の値に設定する	df.fillna(method='bfill')
文字列の中のパターンによる全マッチを使う	re.findall(pattern, s)
平均と標準偏差から乱数を発生させる	random.normalvariate(mu=0.5, sigma=0.2)
グラフの描画で濃い色を使う	sns.set(pallete='deep')
ファイルからの入力ストリームを見る	open(filepath)
リストと列をつなぐ	itertools.chain(iterable, iterable2)
データフレームのカラムの中に文字列がある	df[col].isin([value])
＜オプション＞複素数型を使う	dtype = bool
＜オプション＞グラフの色をマゼンタに設定する	color = 'magenta'
文字列の中の大文字・小文字を無視して正規表現による全てのマッチを使う	re.findall(pattern, s, flags=re.IGNORECASE)
データフレームを二つの列によってによって降順にソートする	df.sort_values(by=['A', 'B'], ascending=False)
折れ線グラフの色をナバホホワイトにセットする	plt.plot(データ列, データ列2, color='navajowhite')
＜オプション＞スラグレー色を使う	color = 'slategray'
＜オプション＞ライトスカイブルーに色を指定する	color = 'lightskyblue'
リストが空か調べる	len(aList) == 0
表データを関数ごとにグループ化して、列挙する	[(name, group) for name, group in df.groupby(関数)]
折れ線グラフに青い下三角印を描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='b')
まとめて正規表現patternでカラムの値をreplに置き換える	ds.replace(pattern, repl, regex=True)
折れ線グラフに黒い右三角印を描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='k')
イテラブルから両端キューを作る	collections.deque(iterable)
カウンタの項目数を使う	len(aCounter)
ポイントマーカーを用いて散布図を描く	plt.plot(xdata, ydata, marker='.')
双方向キューの要素をインプレースに反転する	deq.reverse()
にy=0の点線を設定する	plt.axhline(y=0, linestyle='dotted')
データフレームのNaNを直前の値に指定する	df.fillna(method='ffill')
折れ線グラフの色をライトイエローに変更する	plt.plot(データ列, データ列2, color='lightyellow')
データ列を百の位で丸める	ds.round(-2)
文字の文字コード	ord(ch)
＜オプション＞グラフの色をビスクに変更する	color = 'bisque'
＜オプション＞ミディアムシアグリーンを使う	color = 'mediumseagreen'
表データの先頭n行を見る	df.head(n)
ファイルパスから追加ストリームをオープンして]、fとする	f = open(filepath, mode='a')
＜オプション＞ライトスチールブルーにグラフの色をする	color = 'lightsteelblue'
k進対数	math.log(x, k)
２つのデータフレームを列をキーにして左結合する	pd.merge(df, df2, on=column, how='left')
year年を日付に変換する	datetime.date(year=year, month=1, day=1)
日付データの日数	aDate.day
配列の最小値	np.min(aArray)
ファイルをBOM付きで開く]	open(filepath, encoding='utf_8_sig')
文字列を全て小文字に変換する	s.lower()
ヒストグラムを描画して、その色をハニーデューに設定する	plt.hist(データ列, color='honeydew')
データ列のNaNを中央値で埋める	ds.fillna(ds.median())
文字列をASCIIコード列に変換する	[ord(ch) for ch in s]
ヒストグラムを描画して、色を青緑に設定する	plt.hist(データ列, color='turquoise')
棒グラフをプロットしてグラフ幅をxに設定する	plt.bar(ラベル列, データ列, width=x)
散布図を赤い星マーカーで描画する	plt.plot(xdata, ydata, marker='*', c='r')
＜オプション＞グラフの色をライトコーラルに設定する	color = 'lightcoral'
集合をタプルにする	tuple(aSet)
リストの全ての要素をクリアにする	aList.clear()
列'A'と列'B'をキーとして二つのデータフレームを外部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
イテラブルとイテラブルをペアのリストにする	itertools.zip_longest(iterable, iterable2)
折れ線グラフを描画してその色をフクシアに設定する	plt.plot(データ列, データ列2, color='fuchsia')
線グラフの色をアイボリーに指定する	plt.plot(データ列, データ列2, color='ivory')
＜オプション＞ダークグレーに色を設定する	color = 'darkgrey'
グラフに凡例を入れる	plt.legend()
データフレームの列が文字列が含まれる行を抽出する	df[df[column].str.contains(s)]
整数nの2進文字列を使う	bin(n)[2:]
ファイルからストリームを読み込み、fileとする	file = open(filepath)
実数の逆正接を計算する	math.atan(x)
要素が集合の要素でないか	element not in aSet
文字列を赤色化する	f'\033[31m{value}\033[0m'
データフレームの列の名前をまとめて文字列を文字列に置換する	df.columns = [str(x).replace(s, s2) for x in df.columns]
実行結果を太字にする	f'\033[1m{value}\033[0m'
データフレームを行によって降順でソートする	df.sort_index(ascending=False)
カラムを丸めて、整数型にする	ds.round().astype(int)
ダークスラテグレー色のヒストグラムを描画する	plt.hist(データ列, color='darkslategray')
辞書からキーで指定された項目をポップする	aDict.pop(key)
オブジェクトが名前付きタプルのインスタンスか	hasattr(obj, '_asdict') and hasattr(obj, '_fields')
プロットの描画で暗いパレットを用いる	sns.set(pallete='dark')
二つのデータフレームを縦方向に連結する	pd.concat([df, df2])
文字列の先頭で正規表現に大文字・小文字を無視してマッチするか見る	re.match(pattern, s, flags=re.IGNORECASE)
折れ線グラフの右三角印を黄色にする	plt.plot(データ列, データ列2, marker='>', markerfacecolor='y')
データフレームの列と列のヒートマップを描画する	sns.heatmap(df[[column, column2]].corr())
値を両端キューの末尾に追加する	deq.append(element)
ヒストグラムを描画して、その色をクリムゾンに設定する	plt.hist(データ列, color='crimson')
日付データが日付データより先か	aDate < aDate2
折れ線グラフの色をブランチドアーモンドに設定する	plt.plot(データ列, データ列2, color='blanchedalmond')
ヒストグラムの色をグレーに設定する	plt.hist(データ列, color='gray')
文字列をエラーを無視してバイト列に変換する	s.encode(errors='ignore')
データ列をリストを境界値として分割する	pd.cut(ds, aList)
ヒストグラムの範囲を設定する	plt.hist(データ列, range=(start, end))
辞書の値の一覧	aDict.values()
データフレームのリスト列を小数点以下n桁で丸める	df[aList].round(n)
タイムスタンプデータをn日前にする	aDatetime - datetime.timedelta(days=n)
破壊的にデータフレームから重複を落とす	df.drop_duplicates(inplace=True)
＜オプション＞グラフの色をライムに設定する	color = 'lime'
キーが辞書上で定義済みか調べる	key in aDict
リストと配列の黒色のパステル調のを描く	plt.plot(xdata, ydata, linestyle='pastel', color='k')
タプルの最後の要素を見る	aTuple[-1]
ファイルからnという名前のシートを読む	pd.read_excel(filename, sheet_name=n)
タプルのコンビネーションを得る	itertools.combinations(iterable, n)
データフレームの欠損値を中央値に変更する	df.fillna(df.median())
リストとリストについての散布図に黒い右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>', c='k')
浮動小数点数の最小値	sys.float_info.min
オブジェクトは辞書クラス	isinstance(obj, dict)
空の集合	set()
折れ線グラフを描画してその色をビスクに変更する	plt.plot(データ列, データ列2, color='bisque')
タプルの末尾の要素を使う	aTuple[-1]
データフレームのpercent分位数	df.quantile(percent/100)
イテラブルから複数個、ランダムに選ぶ	random.choices(iterable, k=n)
リストを淡い色のヒストグラムで描画する	plt.hist(xdata, color='muted')
ライトブルーにヒストグラムの色を設定する	plt.hist(データ列, color='lightblue')
折れ線グラフの下三角マーカーのサイズをnに設定する	plt.plot(データ列, データ列2, marker='v', markersize=n)
マップのキーの値	aDict[key]
日付時刻データからn日分、減算する	aDatetime - datetime.timedelta(days=n)
横棒グラフの幅をxにセットする	plt.barh(ラベル列, データ列, width=x)
＜オプション＞グラフの色をナバホホワイトに設定する	color = 'navajowhite'
こんにちは世界と表示する	print('Hello World')
データフレームのカラムの値をValueMapで一度に置き換える	df[col].replace(ValueMap)
x,y,zにそれぞれn,n2,n3を代入する	x, y, z = n, n2, n3
折れ線グラフを描画して、その色をオレンジレッドに指定する	plt.plot(データ列, データ列2, color='orangered')
ヒストグラムを描画して、その色をサドルブラウンに設定する	plt.hist(データ列, color='saddlebrown')
文字列の中で正規表現にマッチした全ての文字列をリストに変換する	re.findall(pattern, s)
＜オプション＞フローラルホワイトを使う	color = 'floralwhite'
ヒストグラムを一点鎖線を用いて描画する	plt.hist(データ列, linestyle='dashbot')
文字列をマゼンタにする	f'\033[35m{value}\033[0m'
＜オプション＞ミディアムアクアマリンに色を設定する	color = 'mediumaquamarine'
リストの中の最大値	max(aList)
データフレームを複数の列によってグループ化し要約統計量を求める	df.groupby(columns).describe()
キーがマップ上で未定義か	key not in aDict
NaNも加えてデータフレームの列をダミー変数に変換する	pd.get_dummies(df[column], dummy_na=True)
データ列を折れ線グラフに描画してマーカーを下三角にする	plt.plot(データ列, データ列2, marker='v')
データ列とラベルを指定して、縦棒グラフを描画する	plt.bar(ラベル列, データ列)
折れ線グラフを描画して、その色をグリーンに指定する	plt.plot(データ列, データ列2, color='green')
データフレーム全体を行によって昇順にソートする	df.sort_index(ascending=True)
データフレームの列がxかつ列がx2であるデータを抽出する	df[(df[column] == x) & (df[column2] == x2)]
データフレームから型の列を抽出する	df.select_dtypes(ty)
線グラフを描画して、その色をダークオーキッドに設定する	plt.plot(データ列, データ列2, color='darkorchid')
値を白色でプリントできる文字列にする	f'\033[37m{value}\033[0m'
折れ線グラフのマーカーを三角にする	plt.plot(データ列, データ列2, marker='^')
ヒストグラムの色をプラムに指定する	plt.hist(データ列, color='plum')
＜オプション＞グラフの色をペルーに設定する	color = 'peru'
上位集合もしくは等しいかどうか	aSet > aSet2
ヒストグラムの色をライトスチールブルーに設定する	plt.hist(データ列, color='lightsteelblue')
データフレームのカラムの最頻値	df[col].mode()
＜オプション＞アイボリー色を使用する	color = 'ivory'
ファイルパスをBOM付きを用いて追加できるようにオープンする]	open(filepath, mode='a', encoding='utf_8_sig')
＜オプション＞ライトグレーを使う	color = 'lightgray'
ヒストグラムを描画して、色をライトスレイグレーに変更する	plt.hist(データ列, color='lightslategrey')
部分文字列で文字列が終わるか調べる	s.endswith(sub)
ファイルパスをオープンして]書き込みストリームを見る	open(filepath, mode='w')
リストとリストについての散布図に赤いポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.', c='r')
日付時刻データの月を使う	aDatetime.month
赤色のバツマーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='x', c='r')
暗い色の折れ線を描画してその線幅をnにセットする	plt.plot(xdata, ydata, linewidth=n, color='dark')
グラフの色を暗くする	sns.set(pallete='dark')
表データを降順でインデックスを用いて並べる	df.sort_index(ascending=False)
2進文字列をバイト列にする	int(s, 2).to_bytes(length=bytesize, byteorder='big')
データ列の第三四分位数	ds.quantile(0.75)
イテラブルを累加したイテラブル	itertools.accumulate(iterable)
＜オプション＞ヘッダをnamesにする	header = names
データフレームのカラムを丸めて、整数型にする	df[col].round().astype(int)
データ列とイテラブルについて淡い色の折れ線を描き、、線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
折れ線グラフの色をパパイヤウィップに設定する	plt.plot(データ列, データ列2, color='papayawhip')
データフレームのリストカラムの欠損値を直前の値で埋める	df[aList].fillna(method='ffill')
データフレームを２つの列によって大きい順に破壊的に並べ直す	df.sort_values(by=['A', 'B'], ascending=False, inplace=True)
＜オプション＞ミスティローズ色を使う	color = 'mistyrose'
数列と配列の折れ線グラフを描画してその色をカラーコードに設定する	plt.plot(xdata, ydata, color=rgb)
数で実数を整数除算する	x // y
ファイルを開く]	open(filepath)
リストと配列について散布図を描いてマーカーの色を明るいに設定する	plt.plot(xdata, ydata, c='bright')
グラフの大きさを設定する	plt.figure(figsize=(width, height))
折れ線グラフの色をパウダーブルーに設定する	plt.plot(データ列, データ列2, color='powderblue')
＜オプション＞アクア色を使用する	color = 'aqua'
データフレームをインポートする	import pandas as pd
色差別ない色を用いてデータ列と配列の散布図を描画する	plt.plot(xdata, ydata, c='colorblind')
リストとリストについての散布図を明るい色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='bright', alpha=0.5)
リストと数列の青いパステル調のを描く	plt.plot(xdata, ydata, linestyle='pastel', color='b')
複数行対応として正規表現で文字列を区切る	re.split(pattern, s, flags=re.MULTILINE)
リストを配列に変換する	np.array(aList)
＜オプション＞右三角マーカーを使う	marker = '>'
折れ線グラフを描画して、その色をオリーブに指定する	plt.plot(データ列, データ列2, color='olive')
関数でデータフレームをまとめたグループ	df.groupby(関数)
ヒストグラムを描画して、その色をミディアムパープルに設定する	plt.hist(データ列, color='mediumpurple')
等量でビン数nとしてデータ列をビン分割する	pd.qcut(ds, n)
部分文字列で文字列を二分し、最初の文字列を使う	s.partition(sub)[0]
データ列をビン分割する	pd.cut(ds, aList)
データフレームを二つの列によって整列して、更新する	df.sort_values(by=['A', 'B'], inplace=True)
＜オプション＞暗い赤色を使う	color = 'darkred'
データフレームのインデックスの一覧	df.index
重なりを見やすく濃い色として散布図を描画する	plt.plot(xdata, ydata, c='deep', alpha=0.5)
データフレームからランダムに抽出する	df.sample()
ヒストグラムを描画して、その色をアリスブルーに設定する	plt.hist(データ列, color='aliceblue')
ヒストグラムを描画して、その色をインディゴに指定する	plt.hist(データ列, color='indigo')
＜オプション＞紺碧色を使う	color = 'azure'
数字を全部使う	string.digits
イテラブルをセットに追加更新する	aSet.update(iterable)
散布図に赤い三角マーカーを使う	plt.plot(xdata, ydata, marker='^', c='r')
ヒストグラムを描画してその色をダークカーキに設定する	plt.hist(データ列, color='darkkhaki')
リストを引数として展開して表示する	print(*aList, sep=',')
日付時刻データと日付時刻データの時間差が何秒か知る	(aDatetime - aDatetime2).total_seconds()
折れ線グラフの色をオリベドラブに設定する	plt.plot(データ列, データ列2, color='olivedrab')
データフレームのn行目を取り出す	df.loc[n]
データフレームを小数点以下n桁で丸める	df.round(n)
ヒストグラムを描画して、その色をシャルトリューズに設定する	plt.hist(データ列, color='chartreuse')
＜オプション＞降順にする	ascending = False
nがn2の倍数でないか調べる	n % n2 != 0
レモンシフォンにヒストグラムの色を設定する	plt.hist(データ列, color='lemonchiffon')
シエナ色の線グラフを描画する	plt.plot(データ列, データ列2, color='sienna')
リストとリストについての散布図に黒い大バツマーカーを描画する	plt.plot(xdata, ydata, marker='X', c='k')
データフレームの中の列を分割する	pd.cut(df[col], aList)
散布図に下三角マーカーを使用する	plt.plot(xdata, ydata, marker='v')
文字列をカンマによって区切って、列挙する	s.split(',')
第一引数で指定されたファイルの名前	sys.argv[1]
＜オプション＞フォレストグリーンを使用する	color = 'forestgreen'
パレットトルコイズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='paleturquoise')
リストの最初を除く	aList[1:]
白色のヒストグラムを描画する	plt.hist(データ列, color='white')
year年を日付時刻にする	datetime.datetime(year=year, month=1, day=1)
＜オプション＞オリーブにグラフの色を設定する	color = 'olive'
＜オプション＞レベッカパープルに色を設定する	color = 'rebeccapurple'
散布図を明るい色で重なりを見やすく描く	plt.plot(xdata, ydata, c='bright', alpha=0.5)
データフレームの中で、列の重複を見る	df.duplicated(subset=column)
ISO書式の文字列を日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
データ列が何月か調べる	ds.dt.month
リストをシアンにする	f'\033[36m{value}\033[0m'
線グラフの色をミディアムスレートブルーに設定する	plt.plot(データ列, データ列2, color='mediumslateblue')
＜オプション＞ペルー色を使う	color = 'peru'
全要素を０で初期化された行列	np.zeros(行数, 列数)
に鉛直方向の実線を付ける	plt.axvline(x=0, linestyle='solid')
オブジェクトは文字列か調べる	isinstance(obj, str)
＜オプション＞深紅を使用する	color = 'crimson'
ヒストグラムを描画して、その色をミディアムスプリンググリーンに設定する	plt.hist(データ列, color='mediumspringgreen')
＜オプション＞ホットピンクを使う	color = 'hotpink'
日付データが日付データと同時	aDate == aDate2
文字列の接頭辞から部分文字列を取り除く	s.removeprefix(sub)
データフレームのリストカラムの尖度	df[aList].skew()
Pandasで文字列を書式で日付データに変換する	pd.to_datetime(s, format='%Y-%m-%d')
文字列中に部分文字列がいくつか含まれるかカウントする	s.count(sub)
ヒストグラムを描画して、その色をダークシアンに設定する	plt.hist(データ列, color='darkcyan')
ファイルパスをSJISを用いて追加できるようにオープンする]	open(filepath, mode='a', encoding='shift_jis')
データ列を折れ線グラフに描画して、マーカーを四角印にする	plt.plot(データ列, データ列2, marker='s')
折れ線グラフを描画してその色をミディアムバイオレットレッドにセットする	plt.plot(データ列, データ列2, color='mediumvioletred')
ファイルをオープンして]、書き込みストリームを使う	open(filepath, mode='w')
リストとリストの黒色の暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='k')
データ列の要約統計量	ds.describe()
折れ線グラフを描画して、その色をトマトに設定する	plt.plot(データ列, データ列2, color='tomato')
ラベンダーブラッシュ色のヒストグラムを描画する	plt.hist(データ列, color='lavenderblush')
Pandasで、フォーマットでデータフレームのcollを日付データに変換する	pd.to_datetime(df[col], format='%Y-%m-%d')
コマンドの第二引数	sys.argv[1]
データフレーム全体をインデックスによって昇順にソートする	df.sort_index(ascending=True)
＜オプション＞改行しない	end = ''
ミディアムスプリンググリーン色のヒストグラムを描画する	plt.hist(データ列, color='mediumspringgreen')
データフレームのカラムを1000の位で丸める	df[col].round(-3)
オブジェクトがタプルの要素でないか調べる	element not in aTuple
列を2回あわせた直積を得る	itertools.product(iterable, repeat=2)
ヒストグラムの色を小麦色に設定する	plt.hist(データ列, color='wheat')
文字列の出力を改行なしに行う	print(value, end='')
追加できるように既存のファイルをUTF8でオープンする]	open(filepath, mode='a', encoding='utf-8')
折れ線グラフの色をライトスチールブルーに変更する	plt.plot(データ列, データ列2, color='lightsteelblue')
データフレームのカラムを10の位で四捨五入する	df[col].round(-1)
折れ線グラフを描画して、色をライトブルーに設定する	plt.plot(データ列, データ列2, color='lightblue')
スクリプトファイルと同じディレクトリのファイルのパス	os.path.join(os.path.dirname(os.path.abspath(__file__)), filepath)
イテラブルを無限に繰り返す	itertools.cycle(iterable)
線グラフを描画してその色をアクアマリンに設定する	plt.plot(データ列, データ列2, color='aquamarine')
データフレームのカラムの空文字をドロップする	df[col].replace('', np.nan).dropna()
線グラフを描画して色をリネンに設定する	plt.plot(データ列, データ列2, color='linen')
丸マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='o')
2つのデータフレームを異なる列をキーとして結合する	pd.merge(df, df2, left_on='A', right_on='B')
棒を描画して、中央寄せする	plt.bar(ラベル列, データ列, align='center')
n番目のシートをファイルのデータフレームとして読み込む	pd.read_excel(filename, sheet_name=n)
リストとリストで濃いグラフをプロットし、、その線幅をnに指定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
文字列の開始位置から終了位置までの範囲で部分文字列の出現をカウントする	s.count(sub, start, end)
データフレームを表示するとき、表示可能な列数の最大値をnに設定する	pd.set_option('display.max_columns', n)
折れ線グラフを描画して、その色を黄色に指定する	plt.plot(データ列, データ列2, color='yellow')
データ列は正規分布からどの程度歪んでいるか見る	ds.kurt()
赤い▼マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='v', c='r')
＜オプション＞グラフの色をライムに変更する	color = 'lime'
ゼロ埋めされた３２ビット整数型の配列	np.zeros(要素数, dtype=np.int16)
ヒストグラムを点線で描画する	plt.hist(データ列, linestyle='dotted')
シーケンスのセット	set(iterable)
データフレームの列をヒストグラムで可視化する	plt.hist(df[column])
リストとリストの折れ線グラフを透明度alphaで描画する	plt.plot(xdata, ydata, alpha=alpha)
データフレームの値を正規表現patternでまとめてreplに置き換える	df.replace(pattern, repl, regex=True)
散布図に黒色の△マーカーを使う	plt.plot(xdata, ydata, marker='^', c='k')
ファイルをBOM付きで書き込み用にオープンする]	open(filepath, mode='w', encoding='utf_8_sig')
折れ線グラフを描画して、その色をロイヤルブルーに設定する	plt.plot(データ列, データ列2, color='royalblue')
カラーコードの大バツマーカーをリストとリストについての散布図に描画する	plt.plot(xdata, ydata, marker='X', c=rgb)
グラフで使う横軸の軸ラベルをuntitledに指定する	plt.xlabel(untitled)
＜オプション＞ラベンダーに色を設定する	color = 'lavender'
文字列の中で複数行対応として正規表現にマッチした全ての文字列をリストに変換する	re.findall(pattern, s, flags=re.MULTILINE)
線グラフを描画してその色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgrey')
＜オプション＞グラフの色をシスルに設定する	color = 'thistle'
データフレームの中の列をビン分割する	pd.cut(df[col], aList)
列のNaNを直前の値に指定する	ds.fillna(method='ffill')
データフレームを複数の列で小さい順に破壊的にソートする	df.sort_values(by=column, ascending=True, inplace=True)
データフレームの重複を見る	df.duplicated()
リストとリストの折れ線グラフを文字列の色で描画する	plt.plot(xdata, ydata, color=s)
データ列を折れ線グラフに描画して、マーカーを大バツ印にする	plt.plot(データ列, データ列2, marker='X')
データフレームのn行目をドロップして、更新する	df.drop(n, axis=0, inplace=True)
＜オプション＞色をピーチパフに設定する	color = 'peachpuff'
データ列の未入力値を中央値に設定する	ds.fillna(ds.median())
ファイルをUTF8としてオープンする]	open(filepath, encoding='utf-8')
正規表現を使う	import re
折れ線グラフの四角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='s', markersize=n)
＜オプション＞改行コードをUNIXに変更する	newline = '\n'
双方向キューのstart番目からendの部分要素を使う	collections.deque(itertools.islice(deq, start, end))
'A'列で降順に破壊的にデータフレームを並べ直す	df.sort_values(by='A', ascending=False, inplace=True)
リスト中の要素が少なくともひとつ真か	any(aList)
データフレームのカラムを100の位で丸めて、整数型にする	df[col].round(-2).astype(int)
データフレームの指定された列を抽出する	df[column]
配列の分散	np.var(aArray)
＜オプション＞改行コードを旧Macに指定する	newline = '\r'
データフレームの列がxでない行をフィルタする	df[df[column] == x]
数式を部分分数として展開する	sympy.apart(e)
文字列の開始位置先に部分文字列が含まれるかどうか調べる	s.find(sub, start) != -1
折れ線グラフを描画して、その色をライムグリーンに設定する	plt.plot(データ列, データ列2, color='limegreen')
nが3で割り切れるか確認する	n % 3 == 0
逆順の両端キューを使う	reversed(deq)
イテラブルの長さを制限する	collections.deque(iterable, maxlen=n)
＜オプション＞グラフの色をアリスブルーに設定する	color = 'aliceblue'
要素∉集合	element not in aSet
＜オプション＞ライトシアン色を使う	color = 'lightcyan'
ヒストグラムを描画して、その色をドジャーブルーに設定する	plt.hist(データ列, color='dodgerblue')
綺麗なプロットを使う準備をする	import seaborn as sns
ヒストグラムの色をミディアムブルーに設定する	plt.hist(データ列, color='mediumblue')
JSONLファイルにデータフレームを書き込む	df.to_excel(filename)
nがn2で割り切れるかどうか	n % n2 == 0
淡い色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='muted')
イテラブルのそれぞれを関数でフィルタする	map(func, iterable)
ヒストグラムを描画して、色をミスティローズに設定する	plt.hist(データ列, color='mistyrose')
データフレームのリストカラムを10の位で丸めて整数にする	df[aList].round(-1).astype(int)
＜オプション＞グラフの色をパープルに設定する	color = 'purple'
実数の常用対数	math.log10(x)
行列の列ごとの最大値	np.max(aArray, axis=0)
プロットの横軸にuntitledというキャプションを付ける	plt.xlabel(untitled)
n個の数値イテラブル	range(n)
柱状グラフをプロットして、透明度をxに指定する	plt.hist(データ列, alpha=x)
グラフのタイトルをuntitledに設定する	plt.title(untitled)
折れ線グラフのダイアモンドマーカーを黄色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
棒グラフを描画する	plt.bar(ラベル列, データ列)
折れ線グラフに黄色い左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='y')
Pandasで、データフレームのcollをフォーマットとして日付データに変換する	pd.to_datetime(df[col], format='%Y-%m-%d')
ファイルをクローズする	f.close()
書式をargsを引数として文字列整形する	formatText.format(*args)
二つの文字列が同じか	s == s2
辞書からカウンタを作る	collections.Counter(aDict)
浮動小数点数の３乗	x ** 3
＜オプション＞シエナ色を使う	color = 'sienna'
折れ線グラフの色をマルーンに設定する	plt.plot(データ列, データ列2, color='maroon')
文字列中にひとつでも非小文字が含まれるか調べる	any(not c.islower() for c in s)
イテラブルをイミュータブルな集合に変換する	frozenset(iterable)
整数nの8進数表現	oct(n)
折れ線グラフにサイズnの大バツ印を描画する	plt.plot(データ列, データ列2, marker='X', markersize=n)
イテラブルのイミュータブルな集合を見る	frozenset(iterable)
イエローグリーンにヒストグラムの色をする	plt.hist(データ列, color='yellowgreen')
文字列を部分文字列で区切って、文字列リストに変換する	s.split(sub)
datetimeをインスタンス化する	datetime.datetime(年, 月, 日, 時, 分, 秒)
ヒストグラムの色を赤に設定する	plt.hist(データ列, color='red')
データフレームを各列毎にグループ化して文字列というグループの個数を算出する	df.groupby(column).size()[s]
ヒストグラムの色をマゼンタに変更する	plt.hist(データ列, color='magenta')
データフレームの内容を見る	df.head()
データフレームを列名リストで整列してNaNを先頭に来るようにする	df.sort_values(by=column, na_position='first')
折れ線グラフの色をブランチドアーモンドに変更する	plt.plot(データ列, データ列2, color='blanchedalmond')
グラフに補足を入れる	plt.legend()
データ列とリストを使って明るいグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
ファイルから1文字、読み込む	f.read(1)
表データを複数の列によってソートして、NaNを先頭にする	df.sort_values(by=column, na_position='first')
リストと配列についての散布図に黒いバツマーカーを描く	plt.plot(xdata, ydata, marker='x', c='k')
有理数の分母	q.denominator
nからn2までの整数列を使う	list(range(n, n2+1))
＜オプション＞スカイブルー色を用いる	color = 'skyblue'
Pandasで、フォーマットで文字列を日付データに変換する	pd.to_datetime(s, format='%Y-%m-%d')
JSONL形式のファイルからデータフレームを読み込む	pd.read_json(filename, orient='records', lines=True)
データフレームの中にいくつが存在するか数える	df.isin([value]).sum()
本日が土曜日かどうか調べる	datetime.datetime.today().weekday() == 5
データフレームから型リストで指定したデータ型の列を除外する	df.select_dtypes(exclude=typeList)
文字列の開始位置から先に部分文字列が含まれないか調べる	s.find(sub, start) == -1
データフレームのカラムの尖度	df[col].skew()
データ列の欠損値を中央値で補う	ds.fillna(ds.median())
カラーコードの右三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
データフレームを行によってソートする	df.sort_index()
xの小数点以下'2'桁までの文字列に変換する	':.2f'.format(x)
データフレームのカラムの値が欠損値か調べる	df[col].isna()
赤い▲マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='^', c='r')
辞書のキーを列挙する	aDict.keys()
折れ線グラフを描画して、その色をライトイエローに設定する	plt.plot(データ列, データ列2, color='lightyellow')
データフレームを各列毎にグループ化して文字列というグループを使う	df.groupby(column).get_group(s)
predicateFuncが真になるイテラブルの要素	itertools.takewhile(predicateFunc, iterable)
リストの要素を昇順にソートする	sorted(aList, reverse=False)
文字列の中でパターンにマッチした全ての文字列をリストにする	re.findall(pattern, s)
文字列が印字できるか	s.isprintable()
折れ線グラフの色をパールバイオレットレッドにセットする	plt.plot(データ列, データ列2, color='palevioletred')
配列とデータ列について黒い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='k')
データ列を四捨五入する	ds.round()
データ列をn個にビン分割して、namesのラベルをつける	pd.cut(ds, n, labels=names)
ヒストグラムの色をグリーンイエローに設定する	plt.hist(データ列, color='greenyellow')
データフレームを小さい順に二つの列でソートする	df.sort_values(by=['A', 'B'], ascending=True)
ブラック色の線グラフを描画する	plt.plot(データ列, データ列2, color='black')
折れ線グラフに線幅nの左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markeredgewidth=n)
グラフで使える色名の一覧を使う	matplotlib.colors.cnames
ファイルをオープンして]、読み込みストリームを使う	open(filepath, mode='r')
実数のn乗して数による余りを計算する	pow(x, n, y)
UTF8で書き込みできるようにファイルをオープンする]	open(filepath, mode='w', encoding='utf-8')
カウンタを集合に変換する	set(aCounter)
折れ線グラフの色をミスティローズに設定する	plt.plot(データ列, データ列2, color='mistyrose')
ユーザの入力を整数として受け取る	int(input())
データ列の中にいくつ欠損値があるか求める	ds.isna().sum()
ヒストグラムを描画して、色を黄色に変更する	plt.hist(データ列, color='yellow')
文字列は全て識別子名か調べる	s.isidentifier()
柱状図をプロットする	plt.hist(データ列)
折れ線グラフを描画して、その色を青に設定する	plt.plot(データ列, データ列2, color='blue')
変数がマイナス無限大に近づく時の数式の極限値を求める	sympy.limit(e, z, -oo)
配列とリストの暗いグラフを描き、、色を黒にする	plt.plot(xdata, ydata, linestyle='dark', color='k')
データフレームからカテゴリデータの列を抽出する	df.select_dtypes('object')
TSVからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
折れ線グラフの色をダークターコイズに設定する	plt.plot(データ列, データ列2, color='darkturquoise')
ヒストグラムの色をパープルに変更する	plt.hist(データ列, color='purple')
箱ひげ図を二つ並べて描画する	plt.boxplot([データ列, データ列2])
ミスティローズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='mistyrose')
オブジェクトを文字列に変換する	str(obj)
小麦色色の線グラフを描画する	plt.plot(データ列, データ列2, color='wheat')
線グラフの色をオリベドラブに設定する	plt.plot(データ列, データ列2, color='olivedrab')
データフレームのインデックスの名前をnameからname2に付け直す	df.rename(index={name: name2})
＜オプション＞グラフの色をライトゴールドロディイエローに設定する	color = 'lightgoldenrodyellow'
リストとリストでパステル調のグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
平均と標準偏差から疑似乱数を生成する	random.normalvariate(mu=0.5, sigma=0.2)
ファイルを開いて]、追加ストリームを使う	open(filepath, mode='a')
散布図をカラーコードの△マーカーで描画する	plt.plot(xdata, ydata, marker='^', c=rgb)
折れ線グラフの線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n)
データフレームの列を100の位で丸める	df[col].round(-2)
折れ線グラフに黄色い下三角マーカーを描画する	plt.plot(データ列, データ列2, marker='v', markerfacecolor='y')
行列の列ごとの最大値を求める	np.max(aArray, axis=0)
nがn2より小さいか調べる	n < n2
データフレームのそれぞれのグループごとの合計	df.groupby(column).sum()
ヒストグラムを描画して、その色をパウダーブルーに設定する	plt.hist(データ列, color='powderblue')
四角マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='s')
３つのデータフレームを縦に連結する	pd.concat([df, df2, df3], axis=0)
上位集合もしくは等しいか調べる	aSet > aSet2
マップをコピーする	dict(aDict)
＜オプション＞シャルトリューズに色を指定する	color = 'chartreuse'
双方向キューに要素をenqueueする	deq.appendleft(element)
文字列を走査しパターンにマッチするか見る	re.search(pattern, s)
データフレームがどの程度、分散しているか調べる	df.var()
＜オプション＞エラーがあるとき例外を発生させる	errors = 'strict'
データフレームを列名リストを用いて昇順に整列し、更新する	df.sort_values(by=column, ascending=True, inplace=True)
サーモン色の線グラフを描画する	plt.plot(データ列, データ列2, color='salmon')
データフレームのカラムの欠損値を直後の値に設定する	df[col].fillna(method='bfill')
＜オプション＞ミディアムパープルにグラフの色を設定する	color = 'mediumpurple'
折れ線グラフの色をアイボリーに設定する	plt.plot(データ列, データ列2, color='ivory')
文字列モジュールをインポートする	import string
色差別ない色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='colorblind', alpha=0.5)
デフォルトスタイルを適用する	sns.set()
折れ線グラフの四角マーカーを緑色にする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='g')
散布図に四角マーカーを使用する	plt.plot(xdata, ydata, marker='s')
データフレームを各列毎にグループ化して、列の合計を求める	df.groupby(column)[column2].sum()
散布図を丸マーカーとして描画する	plt.plot(xdata, ydata, marker='o')
n番目のシートをエクセルファイルファイルからデータフレームとして読み込む	pd.read_excel(filename, sheet_name=n)
データフレームのリスト列のNaNを最小値に設定する	df[aList].fillna(df[aList].min())
折れ線グラフに赤い星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='r')
日付データをISO書式の文字列にする	aDate.isoformat()
ヒストグラムを描画して、その色を淡いピンク色に設定する	plt.hist(データ列, color='lightpink')
線グラフを描画してその色をサドルブラウンに変更する	plt.plot(データ列, データ列2, color='saddlebrown')
配列と配列について破線グラフをプロットしてその色を濃いに変更する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
ヒストグラムを描画して色を貝殻に設定する	plt.hist(データ列, color='seashell')
辞書のキーを要素に設定する	aDict[key] = element
データフレームから指定された二つの列を抽出する	df[[column, column2]]
データフレームの中の列を四分位数ごとにビン分割する	pd.qcut(df[col], 4)
Pandasで、日付データのデータフレームのカラムをデータフレームのインデックスにする	df.index = pd.DatetimeIndex(df[col])
ヒストグラムの色をリネンに設定する	plt.hist(データ列, color='linen')
タイムスタンプデータと日付時刻データの時間差は何分か知る	(aDatetime - aDatetime2).total_seconds()//60
原点から(実数,y)の距離	math.hypot(x, y)
データフレームのリストカラムの中に文字列と文字列がいくつあるか数える	df[aList].isin([value, value2]).sum()
印字可能な文字を全部使う	string.printable
横向きに2つのデータフレームをつなぐ	pd.concat([df, df2], axis=1)
数値のインテグラルを計算する	sympy.integrate(e)
nが3の倍数かどうか調べる	n % 3 == 0
ゼロ埋めされた整数型の配列	np.zeros(要素数, dtype=np.int)
黒い星マーカーを用いて散布図を描画する	plt.plot(xdata, ydata, marker='*', c='k')
CSVファイルファイル名が	filename.endswith('.csv')
ファイルを文字コードtextで書き込み用に開く]	open(filepath, mode='w', encoding=text)
オブジェクトのメモリビュー	memoryview(obj)
データフレームを列によって集約して、それぞれのグループごとの分散を算出する	df.groupby(column).var()
＜オプション＞色をカーキに設定する	color = 'khaki'
ヒストグラムを描画して、その色をライトスカイブルーに設定する	plt.hist(データ列, color='lightskyblue')
日付データを文字列でフォーマットする	"aDate.strftime(""%d/%m/%y"")"
折れ線グラフに線幅nの星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markeredgewidth=n)
行列の行ごとの標準偏差	np.std(aArray, axis=1)
既存のベクトルを元に全要素が1の配列	np.ones_like(aArray)
文字列を空白で区切る	s.split()
四角マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='s')
データ列からユニークな要素を抽出し、リスト化する	ds.unique().tolist()
スレートブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='slateblue')
リストとデータ列についての散布図に星マーカーを描画する	plt.plot(xdata, ydata, marker='*')
カウンタをイテラブルを用いて更新する	aCounter.update(iterable)
データフレームのリストカラムの歪度	df[aList].kurt()
リストと配列の明るいグラフを描画し、、その色を黒にする	plt.plot(xdata, ydata, linestyle='bright', color='k')
ヒストグラムの色をパープルに設定する	plt.hist(データ列, color='purple')
8進文字列を整数に変換する	int(s, 8)
項目名がマッピング上で定義済みか調べる	key in aDict
'A'列の値でデータフレームをグループ化し、要約統計量を求める	df.groupby('A').describe()
辞書をカウンタに変換する	collections.Counter(aDict)
折れ線グラフの印をクロス印にする	plt.plot(データ列, データ列2, marker='x')
オブジェクトの参照カウントを使う	sys.getrefcount(obj)
折れ線グラフの色をモカシンに設定する	plt.plot(データ列, データ列2, color='moccasin')
データフレームを各列毎にグループ分けし、、列の最大値を計算する	df.groupby(column)[column2].max()
データフレームのリスト列の相関行列をヒートマップで描画する	sns.heatmap(df[aList].corr())
二つの関係が真上位集合か調べる	aSet > aSet2
白い折れ線グラフを描画する	plt.plot(データ列, データ列2, color='w')
ヒストグラムの色をダークカーキに設定する	plt.hist(データ列, color='darkkhaki')
整数を３乗する	x ** 3
列によってデータフレームを破壊的に降順にソートする	df.sort_values(by=column, ascending=False, inplace=True)
ファイルを追加モードで開いて]、fとする	f = open(filepath, mode='a')
折れ線グラフを描画して、その色をオリベドラブにセットする	plt.plot(データ列, データ列2, color='olivedrab')
データ列のNaNを最大値で補う	ds.fillna(ds.max())
nがn2より小さいか	n < n2
ヒストグラムを描画して、その色をホワイトスモークに変更する	plt.hist(データ列, color='whitesmoke')
折れ線グラフの色をダークシアグリーンに設定する	plt.plot(データ列, データ列2, color='darkseagreen')
折れ線グラフを描画して、その色をアンティークホワイトに設定する	plt.plot(データ列, データ列2, color='antiquewhite')
データフレームを列でグループ化して、列の要約統計量を計算する	df.groupby(column).describe()[column2]
ヒストグラムを描画して、その色をダークオレンジに設定する	plt.hist(データ列, color='darkorange')
濃い色のヒストグラムでリストを描画する	plt.hist(xdata, color='deep')
オブジェクトひとつのタプル	(element,)
ヒストグラムの色をライトゴールドロディイエローに設定する	plt.hist(データ列, color='lightgoldenrodyellow')
＜オプション＞グラフの色をバリーウッドに設定する	color = 'burlywood'
グラフの補足の場所を(x,y)に設定する	plt.legend(loc=(x, y))
文字列を太字でプリントできる文字列に変換する	f'\033[1m{value}\033[0m'
イテラブルを文字列に変換して連結する	''.join(map(str, iterable))
ふたつの集合が互いに素かどうか調べる	aSet.isdisjoint(aSet2)
データフレームのカラムが正規分布からどの程度、尖っているか見る	df[col].skew()
データフレームを表示するとき、n行までデータフレームを表示できるようにする	pd.set_option('display.max_rows', n)
ダークグリーン色のヒストグラムを描画する	plt.hist(データ列, color='darkgreen')
ファイルとfilenameを結合する	os.path.join(filepath, filename)
トマト色の線グラフを描画する	plt.plot(データ列, データ列2, color='tomato')
データフレームの中にある文字列と文字列の合計を数える	df.isin([value, value2]).sum()
＜オプション＞グラフの色をオレンジレッドに設定する	color = 'orangered'
値を太字化する	f'\033[1m{value}\033[0m'
リストとデータ列についてリストの値に応じて、散布図の色を変える	plt.scatter(xdata, ydata, c=aList, cmap='Blues')
データフレームを表示するとき、表示可能な最大行数を増やす	pd.set_option('display.max_rows', n)
配列とリストで色差別ないの折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
折れ線グラフの下三角マーカーを赤くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='r')
スカイブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='skyblue')
ヒストグラムを描画して、その色をオレンジレッドに設定する	plt.hist(データ列, color='orangered')
ミスティローズにヒストグラムの色を設定する	plt.hist(データ列, color='mistyrose')
線グラフの色をサドルブラウンに設定する	plt.plot(データ列, データ列2, color='saddlebrown')
変数が0に近づくとき、数式の極限値を計算する	sympy.limit(e, z, 0)
＜オプション＞ライトスレイグレーを用いる	color = 'lightslategrey'
データフレームをグループ化し、列に対し最小値を求める	df.groupby(column)[column2].min()
ヒストグラムを描画して、色をライトスカイブルーに設定する	plt.hist(データ列, color='lightskyblue')
＜オプション＞グラフの色をパパイヤウィップに設定する	color = 'papayawhip'
＜オプション＞ポイントマーカーを使う	marker = '.'
カウンタを高頻出な方から列挙する	aCounter.most_common()
データフレームのカラムの秒を見る	df[col].dt.second
ブルーバイオレット色のヒストグラムを描画する	plt.hist(データ列, color='blueviolet')
データフレームを各列と列の組み合わせ毎にグループ化して、最小値を計算する	df.groupby([column, column2], as_index=False).min()
横棒の色をカラーコードに設定する	plt.barh(ラベル列, データ列, color=rgb)
データフレームが重複しているかどうか調べる	df.duplicated()
データフレームを各列毎にグループ化し、、文字列というグループの個数を算出する	df.groupby(column).size()[s]
ボックスチャートを２つ並べて描画する	plt.boxplot([データ列, データ列2])
散布図に赤い丸マーカーを使う	plt.plot(xdata, ydata, marker='o', c='r')
ヒストグラムをカラーマップで描画する	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
スクリプトファイルのディレクトリ名	os.path.dirname(os.path.abspath(__file__))
折れ線グラフに線幅nの丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markeredgewidth=n)
文字列がリストの要素か調べる	element in aList
データフレームをCSVファイルでJSONLファイルに保存する	df.to_csv(filename)
異なる列をキーにして二つのデータフレームを左結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='left')
オブジェクトは集合クラスか調べる	isinstance(obj, set)
ヒストグラムの色をバリーウッドに設定する	plt.hist(データ列, color='burlywood')
＜オプション＞グラフの色をゴーストホワイトに設定する	color = 'ghostwhite'
文字列中から正規表現にマッチする文字列を探す	re.search(pattern, s)
上限nの両端キューをシーケンスから作る	collections.deque(iterable, maxlen=n)
データ列を10の位で丸めて、整数にする	ds.round(-1).astype(int)
リストとリストの青い色差別ないグラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
散布図に黒いポイントマーカーを使う	plt.plot(xdata, ydata, marker='.', c='k')
データフレームのNaNをxに設定する	df.fillna(x)
ファイルをオープンして]バイナリストリームを使う	open(filepath, mode='rb')
リストとリストについての散布図に黒いダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c='k')
＜オプション＞ブランチドアーモンドにグラフの色を変更する	color = 'blanchedalmond'
文字列の最初から余分な空白を除く	s.lstrip()
行列の値を求める	aArray[行番号, 列番号]
ヒストグラムの色を黒くする	plt.hist(データ列, color='k')
線グラフを描画して、その色をグリーンに設定する	plt.plot(データ列, データ列2, color='green')
＜オプション＞ダークグリーンを使う	color = 'darkgreen'
折れ線グラフの色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategray')
ヒストグラムを描画してその色をミディアムスプリンググリーンにセットする	plt.hist(データ列, color='mediumspringgreen')
で使える色名の一覧	matplotlib.colors.cnames
ケンドール相関係数でデータフレームの相関行列	df.corr(method='kendall')
現在の秒数	datetime.date.today().second
文字列の示すエンコーディングを使って追加できるように既存のファイルをオープンする]	open(filepath, mode='a', encoding=s)
日付時刻データをISO書式の文字列にする	aDatetime.isoformat()
小さい順にリストの値を並べ変える	sorted(aList, reverse=False)
TSVファイルでJSONLファイルにデータフレームを保存する	df.to_csv(filename, sep='\t')
列を等量でビン数nとしてビン分割する	pd.qcut(ds, n)
Pandasで、データ列をフォーマットで日付データに変換する	pd.to_datetime(ds, format='%Y-%m-%d')
リストとリストの淡いグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='muted', color='b')
パステル調の色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='pastel')
線グラフを描画して、その色をゴーストホワイトに指定する	plt.plot(データ列, データ列2, color='ghostwhite')
折れ線グラフの三角マーカーを黄色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='y')
ヒストグラムを描画して、その色をサドルブラウンに指定する	plt.hist(データ列, color='saddlebrown')
数列とデータ列についての散布図を明るい色で描く	plt.plot(xdata, ydata, c='bright')
＜オプション＞グラフの色をライトサーモンに設定する	color = 'lightsalmon'
ネイピア数	math.e
＜オプション＞ベージュ色を用いる	color = 'beige'
スピアマンでデータフレームの相関行列	df.corr(method='spearman')
黒いダイアモンドマーカーをリストとリストについての散布図に描く	plt.plot(xdata, ydata, marker='D', c='k')
暗いグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', linewidth=n)
リストとリストについて破線グラフを描画して、その色を淡いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='muted')
サンディーブラウン色の線グラフを描画する	plt.plot(データ列, データ列2, color='sandybrown')
文字列を部分文字列で二分し、最初の文字列を使う	s.partition(sub)[0]
データフレームのリストカラムの中に存在する文字列の合計を数える	df[aList].isin([value]).sum()
データフレームの列の名前を文字列を文字列に置換する	df.columns = [str(x).replace(s, s2) for x in df.columns]
明るいグラフの線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
リストのn番目以降の部分を得る	aList[n:]
ヒストグラムを描画して、その色をドジャーブルーに変更する	plt.hist(データ列, color='dodgerblue')
＜オプション＞グラフの色をホワイトスモークに設定する	color = 'whitesmoke'
データフレームのそれぞれのグループごとの平均値を求める	df.groupby(column).mean()
モカシン色のヒストグラムを描画する	plt.hist(データ列, color='moccasin')
色差別ないグラフの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
折れ線グラフの色をミディアムブルーに設定する	plt.plot(データ列, データ列2, color='mediumblue')
グラフに文字列と文字列と凡例を入れる	plt.legend([s, s2])
折れ線グラフに大きさnの左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markersize=n)
自然数個からk個取り出したときの順列の総数	math.perm(n, k)
折れ線グラフに三角マーカーを加える	plt.plot(データ列, データ列2, marker='^')
等間隔でデータフレームの中の列をn個にビン分割して、namesのラベルをつける	pd.cut(df[col], n, labels=names)
ピンク色の線グラフを描画する	plt.plot(データ列, データ列2, color='pink')
文字列を緑色にする	f'\033[32m{value}\033[0m'
文字列の開始位置と終了位置の間に部分文字列が含まれるか調べる	s.find(sub, start, end) != -1
ヒストグラムを描画して、色をディープスカイブルーに指定する	plt.hist(データ列, color='deepskyblue')
データフレームの列を破壊的に落とす	df.drop(column, axis=1, inplace=True)
＜オプション＞ダイアモンドマーカーを描画する	marker = 'D'
リストとリストについての散布図に赤い星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='r')
リストの末尾にリストを加え、拡張する	aList.extend(aList2)
カラムを100の位で四捨五入する	ds.round(-2)
折れ線グラフを描画して、その色をチョコレートに設定する	plt.plot(データ列, データ列2, color='chocolate')
＜オプション＞グラフの色をビスクに設定する	color = 'bisque'
＜オプション＞ピーチパフ色を用いる	color = 'peachpuff'
自分自身をモジュールとして	sys.modules[__name__]
ふたつのリストの積集合	list(set(aList) & set(aList2))
ヒストグラムを描画して、その色をライトサーモンに指定する	plt.hist(データ列, color='lightsalmon')
＜オプション＞ペールグリーン色を使う	color = 'palegreen'
データフレームがどの程度、分散しているか見る	df.var()
JSON形式の文字列を辞書に変換する	json.loads(jsonString)
折れ線グラフを描画してその色をレベッカパープルに設定する	plt.plot(データ列, データ列2, color='rebeccapurple')
コロンで文字列を区切り、、列挙する	s.split(':')
ヒストグラムの色をオリーブに設定する	plt.hist(データ列, color='olive')
データフレームの値をValueMapで一度に置き換える	df.replace(ValueMap)
配列とリストについて濃い色の折れ線グラフを描画してその線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='deep')
リストとリストで濃いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='deep', linewidth=n)
既存のファイルを文字コードtextとして追加できるようにオープンする]	open(filepath, mode='a', encoding=text)
現在の秒数を使う	datetime.date.today().second
ヒストグラムを描画してその色をミディアムブルーに設定する	plt.hist(データ列, color='mediumblue')
日付時刻データが木曜日かどうか	aDatetime.weekday() == 3
ヒストグラムを描画して、その色をインディアンレッドにセットする	plt.hist(データ列, color='indianred')
タプル上でキーが未定義か判定する	key not in aDict
列の欠損値を中央値に設定する	ds.fillna(ds.median())
＜オプション＞先頭カラムを行に設定する	index_col = 0
バイナリモードでファイルをオープンして]、fとする	f = open(filepath, mode='rb')
配列を平坦化する	aArray.flatten()
日付データは日付データと同時かどうか判定する	aDate == aDate2
＜オプション＞コーンズシルクに色を設定する	color = 'cornsilk'
浮動小数点数の複素数	complex(x)
データフレームの文字列を欠損値にする	df.replace(s, np.nan)
オプションで、標準エラーを使う	file = sys.stderr
散布図に赤い△マーカーを使う	plt.plot(xdata, ydata, marker='^', c='r')
ヒストグラムを描画して、その色を濃い青に変更する	plt.hist(データ列, color='darkblue')
＜オプション＞グラフの色をアンティークホワイトに設定する	color = 'antiquewhite'
オブジェクトがあるクラスか調べる	isinstance(obj, クラス)
無限に文字列が繰り返すイテラブルを得る	itertools.repeat(element)
保存するCSVファイルの小数点以下の桁数を設定する	df.to_csv(filename, float_format='%.3f')
標準出力を使う	sys.stdout
ISO書式の文字列から日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
リストとリストの青い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='b')
変数を黒色化する	f'\033[30m{value}\033[0m'
オブジェクトはタプル	isinstance(obj, tuple)
＜オプション＞ミディアムバイオレットレッドを使う	color = 'mediumvioletred'
nを否定する	not n
ヒストグラムの色をインディアンレッドに設定する	plt.hist(データ列, color='indianred')
＜オプション＞改行コードをWindowsに設定する	newline = '\r\n'
青色の線グラフを描画する	plt.plot(データ列, データ列2, color='blue')
表とデータ列を横方向に連結する	pd.concat([df, ds], axis=1)
プロット中の(x,y)の場所に凡例を表示する	plt.legend(loc=(x, y))
配列とデータ列として折れ線グラフを描画して線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n)
データフレームを列によってソートして、新しいインデックスを加える	df.sort_values(columns).reset_index()
リストの各値を関数に適用した結果で並べ変える	sorted(aList, key=func)
＜オプション＞グラフの色を耐火レンガに設定する	color = 'firebrick'
＜オプション＞色をダークグレーに設定する	color = 'darkgrey'
文字列中から正規表現に大文字・小文字を無視してマッチする文字列を探す	re.search(pattern, s, flags=re.IGNORECASE)
predicateFuncが真とならないリストの要素	itertools.dropwhile(predicateFunc, iterable)
データフレームの各グループごとの平均値	df.groupby(column).mean()
黒い下三角マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='v', c='k')
キューの大きさを求める	len(deq)
長さnのリスト	[0] * n
nが3で割り切れるか調べる	n % 3 == 0
文字列中から正規表現にASCII限定としてマッチする文字列を探す	re.search(pattern, s, flags=re.ASCI)
文字列の中で複数行対応として正規表現にマッチした全ての文字列をリストにする	re.findall(pattern, s, flags=re.MULTILINE)
ファイルがあるか調べる	os.path.exists(filepath)
折れ線グラフのダイアモンドマーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='D', markersize=n)
ヒストグラムを描画して、その色をシルバーに設定する	plt.hist(データ列, color='silver')
グラフのグリッドを暗くする	sns.set(style='darkgrid')
リネン色のヒストグラムを描画する	plt.hist(データ列, color='linen')
ファイルの拡張子なしのファイル名を使う	os.path.splitext(os.path.basename(filepath))[0]
配列と配列の散布図に黒色の▽マーカーを描画する	plt.plot(xdata, ydata, marker='v', c='k')
赤い四角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='r')
＜オプション＞色をオリーブに設定する	color = 'olive'
乱数シードをnで固定する	random.seed(n)
リストとリストの散布図にクロスマーカーを描画する	plt.plot(xdata, ydata, marker='x')
ダークターコイズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkturquoise')
データフレームのリストカラムを100の位で丸める	df[aList].round(-2)
全要素を０で初期化された整数型の行列	np.zeros(行数, 列数, dtype=np.int)
イテラブルのイミュータブルな集合	frozenset(iterable)
＜オプション＞下三角マーカーを描画する	marker = 'v'
現在の作業ディレクトリをfilepathに変更する	os.chdir(os.dirname(filepath))
黒色のポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.', c='k')
＜オプション＞ターコイズ色を使う	color = 'turquoise'
二つの辞書をチェーンする	collections.ChainMap(aDict, aDict2)
文字列に列を変換して、'改行でつなげる	'\n'.join(map(str, iterable))
整数nのビット長を見る	n.bit_length()
線グラフを描画してその色をミスティローズに設定する	plt.plot(データ列, データ列2, color='mistyrose')
折れ線グラフの色をアリスブルーに設定する	plt.plot(データ列, データ列2, color='aliceblue')
バイオレットにヒストグラムの色を設定する	plt.hist(データ列, color='violet')
カラーコードの星マーカーをリストと配列についての散布図に描画する	plt.plot(xdata, ydata, marker='*', c=rgb)
明るい色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='bright')
散布図に黒い▲マーカーを使う	plt.plot(xdata, ydata, marker='^', c='k')
Pythonパス	sys.path
整数nがリストのどれかか確認する	n in aList
文字列は全て数値かどうか調べる	s.isnumeric()
ヒストグラムを描画して、その色をプラムに設定する	plt.hist(データ列, color='plum')
散布図に三角マーカーを使う	plt.plot(xdata, ydata, marker='^')
小さい方からリストの値をソートする	sorted(aList, reverse=True)
データフレームの列に重複があれば、マスクする	df.duplicated(subset=column)
配列と配列の散布図に赤い下三角マーカーをプロットする	plt.plot(xdata, ydata, marker='v', c='r')
折れ線グラフの星マーカーを緑色にする	plt.plot(データ列, データ列2, marker='*', markerfacecolor='g')
文字列を最後から空白で区切る	s.rsplit()
イテラブルと列のデカルト積	itertools.product(iterable, iterable2)
JSONLファイルに小数点以下3桁までデータフレームを保存する	df.to_csv(filename, float_format='%.3f')
TSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
散布図に下三角マーカーを使う	plt.plot(xdata, ydata, marker='v')
データフレームから重複を削除する	df.drop_duplicates()
ヒストグラムの色をシャルトリューズに設定する	plt.hist(データ列, color='chartreuse')
＜オプション＞グラフの色をシエナに設定する	color = 'sienna'
書式を引数としてargsを文字列整形する	formatText.format(*args)
＜オプション＞グラフの色をリネンに設定する	color = 'linen'
浮動小数点数のtanの逆数	math.atan(x)
Pandasで、書式でデータ列をタイムスタンプ型に変換する	pd.to_datetime(ds, format='%Y-%m-%d')
散布図に黒い左三角マーカーを使う	plt.plot(xdata, ydata, marker='<', c='k')
ミディアムターコイズ色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumturquoise')
標準エラーを得る	sys.stderr
ヒストグラムの色をスプリンググリーンに設定する	plt.hist(データ列, color='springgreen')
列自身の長さnの順列を求める	itertools.permutations(iterable, n)
線グラフを描画して、その色をバイオレットに変更する	plt.plot(データ列, データ列2, color='violet')
ヒストグラムを描画してその色をオーキッドに変更する	plt.hist(データ列, color='orchid')
データ列とデータ列の散布図に左三角マーカーを描く	plt.plot(xdata, ydata, marker='<')
スプリンググリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='springgreen')
等間隔でデータフレームの中のカラムをn個にビン分割する	pd.cut(df[col], n)
文字列の中でASCII限定としてパターンにマッチしたすべての文字列をリストに変換する	re.findall(pattern, s, flags=re.ASCI)
ヒストグラムを描画して、その色を青緑に変更する	plt.hist(データ列, color='teal')
＜オプション＞色をブランチドアーモンドに設定する	color = 'blanchedalmond'
散布図を重なりを見やすく明るい色のマーカーでプロットする	plt.plot(xdata, ydata, c='bright', alpha=0.5)
第二引数で指定されたファイルの名前	sys.argv[1]
文字列内にひとつでも大文字が含まれるか調べる	any(c.isupper() for c in s)
0からNまでの配列を初期化する	np.arange(N)
＜オプション＞ライムグリーンに色を指定する	color = 'limegreen'
整数nの八進数文字列	oct(n)[2:]
nが3で割り切れるかどうか調べる	n % 3 == 0
リストの末尾を取り除く	aList[:-1]
リストとリストについての散布図を淡い色を使って描画する	plt.plot(xdata, ydata, c='muted')
黄色いダイアモンドマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='y')
文字列を空白で区切り、、文字列リストに変換する	s.split()
折れ線グラフのダイアモンドマーカーの線幅をnに指定する	plt.plot(データ列, データ列2, marker='D', markeredgewidth=n)
データフレームの列の名前一覧で指定された列を削除する	df.drop(columns, axis=1)
折れ線グラフの色をミディアムオーキッドに指定する	plt.plot(データ列, データ列2, color='mediumorchid')
文字列を赤色で表示する	print(f'\033[31m{value}\033[0m')
ペールグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='palegreen')
イテラブルを出現回数して、カウンタを更新する	aCounter.update(iterable)
ヒストグラムの線のスタイルを破線に設定する	plt.hist(データ列, linestyle='dashed')
リストとリストについて散布図を描画して、ダイアモンドマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='D', c=rgb)
白いヒストグラムを描画する	plt.hist(データ列, color='w')
折れ線グラフに大きさnの星マーカーを描画する	plt.plot(データ列, データ列2, marker='*', markersize=n)
データフレームをJSONLファイルにヘッダを付けずに保存する	df.to_csv(filename, header=None)
リストとリストの相関を可視化する	plt.scatter(xdata, ydata)
＜オプション＞グラフの色をライムに指定する	color = 'lime'
カラーコードの星マーカーで散布図を描く	plt.plot(xdata, ydata, marker='*', c=rgb)
要素∈集合	element in aSet
書式を辞書でフォーマットする	formatText.format_map(aDict)
グリーンイエロー色の線グラフを描画する	plt.plot(データ列, データ列2, color='greenyellow')
データフレームのリスト列の文字列を未入力値に変換する	df[aList].replace(s, np.nan)
折れ線グラフに赤い三角印を描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
文字列が全てアスキー文字	s.isascii()
ロードされたモジュールを列挙する	sys.modules
下線付きで変数をプリントする	print(f'\033[4m{value}\033[0m')
青緑色のヒストグラムを描画する	plt.hist(データ列, color='teal')
データフレームの列からユニークな要素を抽出し、リスト化する	df[col].unique().tolist()
再帰が何回までできるか、知る	sys.getrecursionlimit()
数列とリストの青いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='b')
＜オプション＞グラフの色をゴールデンロッドに設定する	color = 'goldenrod'
折れ線グラフの▲マーカーを黒色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='k')
各列毎にデータフレームをグループ化して列の合計を求める	df.groupby(column)[column2].sum()
折れ線グラフを描画してその色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgrey')
折れ線グラフを一点鎖線として描画する	plt.plot(データ列, データ列2, linestyle='dashbot')
最初のコマンド引数を調べる	sys.argv[1]
＜オプション＞スラッシュをセパレータで使う	sep = '/'
数列をy座標リストを横軸と設定して、折れ線をプロットする	plt.plot(xdata, ydata)
散布図に色差別ない色のマーカーを使う	plt.plot(xdata, ydata, c='colorblind')
mathをインポートする	import math
ヒストグラムを描画して、色を赤に設定する	plt.hist(データ列, color='red')
デピンク色のヒストグラムを描画する	plt.hist(データ列, color='deeppink')
折れ線グラフを描画して、その色を小麦色に設定する	plt.plot(データ列, データ列2, color='wheat')
パステル調のの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
辞書上でキーが定義済みか調べる	key in aDict
TSVファイルからデータフレームを読む	pd.read_csv(filename, sep='\t', encoding='shift_jis')
黒い丸マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='o', c='k')
実数を実数で割った余り	x % y
データフレームはどれだけ、分散しているか見る	df.var()
データフレームを'A'列の値でグループ化し、記述統計量を求める	df.groupby('A').describe()
＜オプション＞コーンフラワーブルー色を使う	color = 'cornflowerblue'
昇順に'A'列と'B'列によってデータフレームをソートして、更新する	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
黒い▽マーカーを使って散布図を描画する	plt.plot(xdata, ydata, marker='v', c='k')
値が集合に含まれる	element in aSet
浮動小数点数の最大値	sys.float_info.max
日付時刻データの時間	aDatetime.hour
表データの列と列に重複があれば、削除する	df.drop_duplicates(subset=[column, column2])
データフレームのリストカラムの空文字を欠損値に変換し、ドロップする	df[aList].replace('', np.nan).dropna()
文字列の右端からタブを消す	s.rstrip('\t')
データフレームを列によってソートして、上位n件を取り出す	df.sort_values(columns).head(n)
文字列を右トリムする	s.rstrip()
データフレームのリスト列の欠損値を中央値で埋める	df[aList].fillna(df[aList].median())
線グラフを描画して、その色をシルバーに指定する	plt.plot(データ列, データ列2, color='silver')
＜オプション＞ダークサーモン色を使用する	color = 'darksalmon'
ヒストグラムを描画して、色をパープルに設定する	plt.hist(データ列, color='purple')
部分文字列を文字列の末尾から探す	s.rfind(sub)
二つの実行結果をタブで区切ってプリントする	print(value, value2, sep='\t')
ダークグレー色のヒストグラムを描画する	plt.hist(データ列, color='darkgrey')
タプルとタプルを連結する	aTuple + aTuple2
＜オプション＞SJISを使う	encoding = 'shift_jis'
グラフを画面用に設定する	sns.set(context='notebook')
既存の配列を元に全要素が0の配列を作る	np.zeros_like(aArray)
文字列のケースを逆にする	s.swapcase()
リストと配列の散布図を描画して、マーカーの色を淡いに設定する	plt.plot(xdata, ydata, c='muted')
space	' '
浮動小数点数が負か調べる	x < 0
リストを引数として展開して出力する	print(*aList, sep=',')
ヒストグラムを描画して、その色をライトシアンに設定する	plt.hist(データ列, color='lightcyan')
データフレームを列によってソートして、インデックスを振り直す	df.sort_values(columns).reset_index(drop=True)
＜オプション＞色を黄色に設定する	color = 'yellow'
黄色で値をプリントする	print(f'\033[33m{value}\033[0m')
nからn2までの整数列	list(range(n, n2+1))
ヒストグラムを描画して、色を珊瑚に設定する	plt.hist(データ列, color='coral')
＜オプション＞改行なし	end = ''
ベクトルの差	aArray - aArray2
＜オプション＞色をダークスレートブルーに変更する	color = 'darkslateblue'
データフレームのリストカラムの欠損値を平均値に設定する	df[aList].fillna(df[aList].mean())
nとn2の積を算出する	n * n2
折れ線グラフを描画して、その色をラベンダーに変更する	plt.plot(データ列, データ列2, color='lavender')
データフレームを列を用いて並べ直してNaNを先頭に来るようにする	df.sort_values(by=column, na_position='first')
ヒストグラムを描画して、色をサンディーブラウンに設定する	plt.hist(データ列, color='sandybrown')
ヒストグラムを描画して、その色をスノーに設定する	plt.hist(データ列, color='snow')
＜オプション＞グラフの色をスラグレーに設定する	color = 'slategrey'
＜オプション＞n番目のカラムをインデックスに設定する	index_col = n
ヒストグラムを描画してその色をダークゴールデンロッドに設定する	plt.hist(データ列, color='darkgoldenrod')
ライトグリーンにヒストグラムの色を指定する	plt.hist(データ列, color='lightgreen')
データフレームのNaNを平均値に減らす	df.fillna(df.mean())
色差別ないの折れ線をプロットし、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
nが2で割り切れるか調べる	n % 2 == 0
折れ線グラフに青い左三角マーカーを描画する	plt.plot(データ列, データ列2, marker='<', markerfacecolor='b')
三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^')
折れ線グラフの色をロージーブラウンに設定する	plt.plot(データ列, データ列2, color='rosybrown')
＜オプション＞アイボリー色を使う	color = 'ivory'
データフレームをサンプリングする	df.sample()
降順に複数の列によってによってデータフレームを並べ直す	df.sort_values(by=column, ascending=False)
ヒストグラムを描画して、その色を紺に設定する	plt.hist(データ列, color='darkblue')
＜オプション＞グラフの色をミディアムスプリンググリーンに設定する	color = 'mediumspringgreen'
リストを暗い色のヒストグラムで描画する	plt.hist(xdata, color='dark')
変数の値をスワップする	x, y = y, x
文字列をSJISでバイト列に変換する	s.encode(encoding='sjis', errors='ignore')
ヒストグラムを描画してその色をライトイエローに設定する	plt.hist(データ列, color='lightyellow')
折れ線グラフを描画して、その色を白に設定する	plt.plot(データ列, データ列2, color='white')
＜オプション＞グラフの色をパールバイオレットレッドに設定する	color = 'palevioletred'
実数を実数に掛ける	x * y
文字列を赤色にする	f'\033[31m{value}\033[0m'
ミディアムバイオレットレッド色のヒストグラムを描画する	plt.hist(データ列, color='mediumvioletred')
文字列の末尾	s[-1]
散布図を描画する	plt.scatter(xdata, ydata)
リストとデータ列の散布図に赤色のポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.', c='r')
実数のバイナリ対数	math.log2(x)
折れ線グラフを描画して、その色をゴールデンロッドに変更する	plt.plot(データ列, データ列2, color='goldenrod')
線グラフの色をターコイズに設定する	plt.plot(データ列, データ列2, color='turquoise')
＜オプション＞ダークオーキッド色を使用する	color = 'darkorchid'
線グラフの色をサンディーブラウンに設定する	plt.plot(データ列, データ列2, color='sandybrown')
＜オプション＞丸マーカーを描画する	marker = 'o'
文字列中の部分文字列を新しい文字列に置き換える	s.replace(sub, newsub)
アルファベットを全て求める	string.ascii_letters
リストの文字列が最初に見つかるインデックスを探す	aList.index(element)
＜オプション＞改行コードを旧Macに設定する	newline = '\r'
明るい色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='bright', alpha=0.5)
標準入力から1行読み取る	input()
ピアソンでデータフレームのリスト列の相関行列	df[aList].corr(method='pearson')
折れ線グラフの色をホットピンクに変更する	plt.plot(データ列, データ列2, color='hotpink')
データフレームから型リストで指定されたデータ型の列を除外する	df.select_dtypes(exclude=typeList)
＜オプション＞菱形印を用いる	marker = 'D'
数値時刻のデータフレームのcollからタイムスタンプ型にする	pd.to_datetime(df[col], unit='s', utc=True)
リストとリストのカラーコードのパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
赤色の大バツマーカーを使って散布図を描く	plt.plot(xdata, ydata, marker='X', c='r')
ヒストグラムを描画して、その色をフォレストグリーンに設定する	plt.hist(データ列, color='forestgreen')
辞書のキーを列挙する	list(aDict)
＜オプション＞タン色を使う	color = 'tan'
ヒストグラムの色をダークシアグリーンにする	plt.hist(データ列, color='darkseagreen')
十六進文字列をバイト列に変換する	int(s, 16).to_bytes(length=bytesize, byteorder='big')
グラフの中の縦軸にuntitledというラベルをつける	plt.ylabel(untitled)
CSVファイルを読み込む	pd.read_csv(filename, sep=',')
線グラフを描画してその色をライトグリーンにセットする	plt.plot(データ列, データ列2, color='lightgreen')
文字のユニコード	ord(ch)
＜オプション＞グラフの色を黄色にする	color = 'yellow'
＜オプション＞グラフの色をハニーデューに変更する	color = 'honeydew'
データフレームの母標準偏差	df.std(ddof=0)
リストから配列を作る	np.array(aList)
文字列を改行で区切る	s.splitlines()
リストとリストで折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n)
線グラフを描画して、その色をスレートブルーに設定する	plt.plot(データ列, データ列2, color='slateblue')
列をダミー変数に変換する	pd.get_dummies(iterable)
チョコレート色のヒストグラムを描画する	plt.hist(データ列, color='chocolate')
ライトコーラル色のヒストグラムを描画する	plt.hist(データ列, color='lightcoral')
リストの重複を取り除く	sorted(set(aList), key=aList.index)
ベクトル演算をする	import numpy as np
折れ線グラフを描画して、その色をラベンダーブラッシュに変更する	plt.plot(データ列, データ列2, color='lavenderblush')
文字列をシンボルにして、パラメータにする	z = sympy.Symbol(s)
eの小数点数乗を求める	math.exp(x)
ひとつでも数字が文字列内にあるか	any(c.isdigit() for c in s)
リストと配列について暗い色の折れ線を描画し、、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
明るいの折れ線グラフの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
リストとリストのカラーコードの明るいグラフを描画する	plt.plot(xdata, ydata, linestyle='bright', color=rgb)
オールドレース色のヒストグラムを描画する	plt.hist(データ列, color='oldlace')
実数のn乗を求める	x ** n
大きい順にデータフレームを'A'列によってによってソートする	df.sort_values(by='A', ascending=False)
変数がマイナス無限大に近づく際の数式の極限値を求める	sympy.limit(e, z, -oo)
ヒストグラムを描画して、その色をホワイトスモークに設定する	plt.hist(データ列, color='whitesmoke')
リストを緑色化する	f'\033[32m{value}\033[0m'
実行時の標準出力の出力先がターミナル	sys.stdout.isatty()
プラットフォームの文字コードの最大値を調べる	sys.maxunicode
nが5で割り切れるかどうか確認する	n % 5 == 0
文字列リストに列を変換してカンマで結合する	','.join(map(str, iterable))
エラーなく文字列の右側から部分文字列を消す	s.removesuffix(sub)
ヒストグラムの色をシーグリーンにする	plt.hist(データ列, color='seagreen')
ヒストグラムを描画して、透明度をxに変更する	plt.hist(データ列, alpha=x)
日本語が文字列中に含まれる	re.search('[あ-んア-ン\u4E00-\u9FD0]', s)
データフレームの末尾	df.tail()
ゼロ埋めされた配列	np.zeros(要素数)
配列の平均を算出する	np.mean(aArray)
辞書から最後に追加したエントリを取り出す	aDict.popitem()
nが偶数か確認する	n % 2 == 0
データフレームから指定された三つの列だけ取り出す	df[[column, column2, column3]]
リストとデータ列の破線グラフを描画してその色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
データ列の中にある文字列の数を求める	ds.isin([value]).sum()
実数の逆余弦を算出する	math.acos(x)
ワーキングディレクトリをfilepathに変更する	os.chdir(os.dirname(filepath))
折れ線グラフを描画して、その色を紺に設定する	plt.plot(データ列, データ列2, color='darkblue')
リストとリストの青い暗いグラフをプロットする	plt.plot(xdata, ydata, linestyle='dark', color='b')
文字列を緑色でプリントできる文字列に変換する	f'\033[32m{value}\033[0m'
日付時刻データの月数	aDatetime.month
データ列の文字列を欠損値に変換する	ds.replace(s, np.nan)
破線の色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
文字列をシアンでプリントできる文字列に変換する	f'\033[36m{value}\033[0m'
ファイルをSJISとしてオープンする]	open(filepath, encoding='shift_jis')
データフレームのカラムと列に重複があればマスクする	df.duplicated(subset=[column, column2])
＜オプション＞ダークオリーブグリーンにグラフの色を設定する	color = 'darkolivegreen'
折れ線グラフを描画して、その色をマルーンに設定する	plt.plot(データ列, データ列2, color='maroon')
year年month月day日を日付に変換する	datetime.date(year=year, month=month, day=day)
列の文字列を欠損値にする	ds.replace(s, np.nan)
配列とリストの黒い濃いグラフを描画する	plt.plot(xdata, ydata, linestyle='deep', color='k')
配列をビン分割する	pd.cut(aArray, aList)
グラフの文字化けを防ぐ	sns.set(font='IPAexGothic')
文字列中から正規表現に複数行対応としてマッチする文字列を探す	re.search(pattern, s, flags=re.MULTILINE)
数列と数列について明るい色の折れ線グラフを描画して、線幅をnにする	plt.plot(xdata, ydata, linewidth=n, color='bright')
複素数を求める	complex(x, y)
＜オプション＞グラフの色をライトスチールブルーに設定する	color = 'lightsteelblue'
折れ線グラフの色をダークゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='darkgoldenrod')
リストとリストについての散布図にカラーコードのポイントマーカーを描画する	plt.plot(xdata, ydata, marker='.', c=rgb)
オブジェクトのバイトサイズ	sys.getsizeof(obj)
ヒストグラムを描画して、その色をブルーバイオレットに変更する	plt.hist(データ列, color='blueviolet')
列によってデータフレームを集約し、、標準偏差を求める	df.groupby(column).std()
文字コードに対応する文字	chr(unicode)
整数を整数に変換する	int(x)
＜オプション＞カデットブルーを使う	color = 'cadetblue'
折れ線グラフの色をミディアムバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='mediumvioletred')
データフレームから重複する行を削除する	df.drop_duplicates()
CSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep=',')
ヒストグラムを描画して、その色をダークカーキに設定する	plt.hist(データ列, color='darkkhaki')
折れ線グラフを描画して、色をダークシアグリーンに設定する	plt.plot(データ列, データ列2, color='darkseagreen')
ファイルをUTF8でオープンする]	open(filepath, encoding='utf-8')
カウンタを低頻度方から列挙する	aCounter.most_common()[::-1]
折れ線グラフの色をダーク・スラテグレーに設定する	plt.plot(データ列, データ列2, color='darkslategrey')
配列とリストについて淡い色の折れ線を描画し、その線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='muted')
ファイルを読み込みモードでオープンする]	open(filepath, mode='r')
＜オプション＞グラフの色を黄色に設定する	color = 'yellow'
散布図に四角マーカーを用いる	plt.plot(xdata, ydata, marker='s')
リストとリストについて散布図を描画して、マーカーを右三角に設定する	plt.plot(xdata, ydata, marker='>')
ライムグリーン色のヒストグラムを描画する	plt.hist(データ列, color='limegreen')
リストと数列について散布図を描画して、下三角マーカーの色をカラーコードにセットする	plt.plot(xdata, ydata, marker='v', c=rgb)
列に列を続けたイテラブル	itertools.chain(iterable, iterable2)
2つの文字列をスラッシュで区切ってプリントする	print(value, value2, sep='/')
黒い星マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='*', c='k')
オブジェクトがリストに含まれないか調べる	element not in aList
＜オプション＞グラフの色をサーモンに設定する	color = 'salmon'
＜オプション＞グラフの色をダークシアグリーンに設定する	color = 'darkseagreen'
nがn2か	n == n2
リストの合計	sum(aList)
＜オプション＞ライトサーモン色を使う	color = 'lightsalmon'
データフレームの列の各データ値の出現数	df[col].value_counts()
ディムグレー色のヒストグラムを描画する	plt.hist(データ列, color='dimgrey')
折れ線グラフを描画して、その色をミディアムシアグリーンに設定する	plt.plot(データ列, データ列2, color='mediumseagreen')
オブジェクトは文字列クラスのインスタンス	isinstance(obj, str)
データフレームのカラムを丸める	df[col].round()
配列とリストについて散布図を描き、、マーカーをダイアモンドに設定する	plt.plot(xdata, ydata, marker='D')
ヒストグラムの色をナバホホワイトに設定する	plt.hist(データ列, color='navajowhite')
行列の行列積	np.matmul(aArray, aArray2)
浮動小数点数の値が整数か	x.is_integer()
符号付き整数の最大値	sys.maxsize
データフレームの列名を一度に文字列を文字列に置換する	df.columns = [str(x).replace(s, s2) for x in df.columns]
部分文字列が文字列の開始位置と終了位置の間に含まれるか調べる	s.find(sub, start, end) != -1
データフレームを複数の列によって昇順にソートする	df.sort_values(by=column, ascending=True)
イテラブルから上限nの両端キューを用意する	collections.deque(iterable, maxlen=n)
グラフにy=0の実線を付ける	plt.axhline(y=0, linestyle='solid')
データフレームの列を消す	df.drop(column, axis=1)
＜オプション＞パールバイオレットレッド色を使う	color = 'palevioletred'
ヒストグラムを描画して、その色をグレーに設定する	plt.hist(データ列, color='grey')
青色の濃いグラフを描く	plt.plot(xdata, ydata, linestyle='deep', color='b')
ファイルからバイナリ書き込みストリームを開き]fとする	f = open(filepath, mode='wb')
コーンフラワーブルーにヒストグラムの色を設定する	plt.hist(データ列, color='cornflowerblue')
折れ線グラフに黄色い大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='y')
横棒グラフの色をカラーコードに設定する	plt.barh(ラベル列, データ列, color=rgb)
データフレームの列の文字列長を列として使う	df[col].str.len()
文字列の先頭で大文字・小文字を無視してパターンにマッチさせる	re.match(pattern, s, flags=re.IGNORECASE)
リストの合計値	sum(aList)
＜オプション＞黄色色を使う	color = 'yellow'
文字列の右側から部分文字列を取り除く	s.rstrip(sub)
ヒストグラムを描画して、その色をダークターコイズにセットする	plt.hist(データ列, color='darkturquoise')
折れ線グラフに赤いポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='r')
データ列と配列について暗いグラフを描画してその色を青くする	plt.plot(xdata, ydata, linestyle='dark', color='b')
文字列はタプルに含まれない	element not in aTuple
ヒストグラムの色をオリベドラブに設定する	plt.hist(データ列, color='olivedrab')
year年の日付時刻	datetime.datetime(year=year, month=1, day=1)
文字列の末尾から範囲を指定して部分文字列を探す	s.find(sub, start, end)
文字列で区切って二つの文字列を出力する	print(value, value2, sep=s)
変数を赤色でプリントする	print(f'\033[31m{value}\033[0m')
＜オプション＞スチールブルー色を使う	color = 'steelblue'
数列とリストについての散布図に▽マーカーを描く	plt.plot(xdata, ydata, marker='v')
データフレームのリストカラムの値はNaNか調べる	df[aList].isna()
折れ線グラフを描画して色をスノーに設定する	plt.plot(データ列, データ列2, color='snow')
データ列の各値の出現数	ds.value_counts()
折れ線グラフを描画して、その色をオレンジに設定する	plt.plot(データ列, データ列2, color='orange')
折れ線グラフの色をミディアムアクアマリンに設定する	plt.plot(データ列, データ列2, color='mediumaquamarine')
＜オプション＞先頭カラムを行に減らす	index_col = 0
要素が集合のメンバーか調べる	element in aSet
n割るn2	n / n2
データフレームの重複した行のみを抽出する	df[df.duplicated(keep=False)]
空のリスト	[]
n個の整数列	list(range(n))
データフレームのリストカラムを10の位で丸めて、整数型にする	df[aList].round(-1).astype(int)
茶色色の線グラフを描画する	plt.plot(データ列, データ列2, color='brown')
黄色い折れ線グラフを描画する	plt.plot(データ列, データ列2, color='y')
nかつn2	n and n2
カーキ色の線グラフを描画する	plt.plot(データ列, データ列2, color='khaki')
データフレームの列と列の相関行列	df[[column, column2]].corr()
数式を数値計算する	float(e)
折れ線グラフの色をダークマゼンタに設定する	plt.plot(データ列, データ列2, color='darkmagenta')
シアン色のヒストグラムを描画する	plt.hist(データ列, color='cyan')
追加できるようにファイルをオープンする]	open(filepath, mode='a')
折れ線グラフの色をスノーに設定する	plt.plot(データ列, データ列2, color='snow')
配列の列を選択する	aArray[:, 列番号]
黄色いバツマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='y')
データフレームをグループ化し、列に対し合計を計算する	df.groupby(column)[column2].sum()
表データに重複があるか見る	df.duplicated()
カウンタをリセットする	aCounter.clear()
プログラムをここで停止する	sys.exit()
データフレームを関数によってまとめたグループ	df.groupby(関数)
データフレームのリスト列の最頻値を求める	df[aList].mode()
日付データが日付データよりあとか調べる	aDate > aDate2
データフレームを表示するとき、表示可能な最大行数を変更する	pd.set_option('display.max_rows', n)
ベクトルの演算をする	import numpy as np
ゼロ埋めされた行列	np.zeros(行数, 列数)
ひとつでも小文字が文字列内にある	any(c.islower() for c in s)
中央値でデータフレームの中の列をビン分割する	pd.qcut(df[col], 2)
データフレームの列の正規分布に対する上下広がり	df[col].skew()
データフレームの内で、列と列に重複があるか確認する	df.duplicated(subset=[column, column2])
リストを縦軸、リストを横軸と指定して、折れ線グラフを描画する	plt.plot(xdata, ydata)
オブジェクトのプロパティを取り除く	delattr(obj, プロパティ名)
値がセットのメンバーかどうか調べる	element in aSet
リストとリストについて黒い淡いグラフをプロットする	plt.plot(xdata, ydata, linestyle='muted', color='k')
リストとリストについての散布図に黒色の菱形マーカーを描く	plt.plot(xdata, ydata, marker='D', c='k')
文字列中からパターンに大文字・小文字を無視してマッチする文字列を探す	re.search(pattern, s, flags=re.IGNORECASE)
リストとリストについての散布図にカラーコードの左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c=rgb)
文字列中にひとつでも非小文字が含まれる	any(not c.islower() for c in s)
データ列をヒストグラムにする	plt.hist(ds)
列をキーにして二つのデータフレームを内部結合する	pd.merge(df, df2, on=column, how='inner')
データフレームを表示するとき、ヘッダー行を左寄せに設定する	pd.set_option('colheader_justify', 'left')
実数が負の数か調べる	x < 0
標準出力のバッファをフラッシュする	sys.stdout.flush()
イテラブルをカウントしてカウンタを更新する	aCounter.update(iterable)
＜オプション＞先頭の行をヘッダにセットする	header = 0
＜オプション＞ブラック色を使う	color = 'black'
整数nを16進表記に変換する	hex(n)
データフレームから指定された列を抽出する	df[[column]]
配列とリストについて破線を描画し、その色を濃いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='deep')
マゼンタにヒストグラムの色を設定する	plt.hist(データ列, color='magenta')
両端キューを空にする	deq.clear()
データフレームの列を度数分布図で可視化する	plt.hist(df[column])
上限制限された長さnの双方向キューを列から作成する	collections.deque(iterable, maxlen=n)
ミディアムバイオレットレッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='mediumvioletred')
数式の因数分解を行う	sympy.factor(e)
キューの要素を右にn個分輪番で回す	deq.rotate(n)
行列の逆行列を計算する	np.linalg.inv(aArray)
日付時刻データが何月か知る	aDatetime.month
＜オプション＞ミディアムブルー色を使う	color = 'mediumblue'
データフレームのn行目を破壊的に削除する	df.drop(n, axis=0, inplace=True)
黒い四角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='s', c='k')
折れ線の色をカラーコードに設定する	plt.plot(xdata, ydata, color=rgb)
折れ線グラフを描画して、色をライトスチールブルーに設定する	plt.plot(データ列, データ列2, color='lightsteelblue')
行列の行列積を計算する	np.matmul(aArray, aArray2)
折れ線グラフに緑色の四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='g')
シーグリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='seagreen')
ヒストグラムを描画して、その色をダークオリーブグリーンに設定する	plt.hist(データ列, color='darkolivegreen')
折れ線グラフを描画して、その色をライトグレーに設定する	plt.plot(データ列, データ列2, color='lightgrey')
リストとデータ列の折れ線グラフを描画し、アルファをalphaに設定する	plt.plot(xdata, ydata, alpha=alpha)
横軸のラベルをuntitledに指定する	plt.xlabel(untitled)
散布図に赤い左三角マーカーを使う	plt.plot(xdata, ydata, marker='<', c='r')
データフレームのリストカラムを1000の位で丸めて整数型にする	df[aList].round(-3).astype(int)
整数nを十六進数文字列にする	hex(n)[2:]
nが奇数かどうか調べる	n % 2 == 1
プロットをスライド用に設定する	sns.set(context='talk')
＜オプション＞オレンジレッドを用いる	color = 'orangered'
折れ線グラフを描画して、その色をミディアムバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='mediumvioletred')
折れ線グラフを描画して、その色をアクアに設定する	plt.plot(データ列, データ列2, color='aqua')
カラムの未入力値をxに指定する	ds.fillna(x)
黒い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='k')
タプルの末尾からn番目以前の部分を取り出す	aTuple[:-n]
データ列の中にある文字列の個数を数える	ds.isin([value]).sum()
ふたつの集合は集合と互いに素か調べる	aSet.isdisjoint(aSet2)
辞書のの一覧を得る	aDict.values()
配列とイテラブルの折れ線を透明度alphaで描画する	plt.plot(xdata, ydata, alpha=alpha)
マッピングの浅いコピーを新規生成する	aDict.copy()
日付時刻データは日付時刻データより後ろか調べる	aDatetime > aDatetime2
データフレームのカラムの母標準偏差	df[col].std(ddof=0)
＜オプション＞ブルーバイオレットにグラフの色を設定する	color = 'blueviolet'
折れ線グラフに右三角印を使う	plt.plot(データ列, データ列2, marker='>')
青い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='b')
Pandasで、日付データのデータ列をデータフレームのインデックスにする	df.index = pd.DatetimeIndex(ds)
実数の正弦	math.sin(x)
最大値・最小値で整数乱数を発生させる	random.randint(最小値, 最大値)
文字列の先頭で正規表現に大文字・小文字を無視してマッチするか調べる	re.match(pattern, s, flags=re.IGNORECASE)
エクセルファイルファイルから全てのシートを読み込む	pd.read_excel(filename, sheet_name=None)
ダークターコイズ色のヒストグラムを描画する	plt.hist(データ列, color='darkturquoise')
JSONLファイルを読み込む	pd.read_json(filename, orient='records', lines=True)
タン色の線グラフを描画する	plt.plot(データ列, データ列2, color='tan')
データフレームの列がx、かつ列がx2である行を選択する	df[(df[column] == x) & (df[column2] == x2)]
行列間の要素ごとの最大公約数	np.gcd(aArray, aArray2)
nが無限に続く数列	itertools.repeat(n)
バイナリできるようにファイルをオープンする]	open(filepath, mode='rb')
nをバイナリに変換する	n.to_bytes((n.bit_length() + 7) // 8, byteorder='big')
ValueMapでデータフレームの値を置き換える	df.replace(ValueMap)
リストにリストを追加する	aList.extend(aList2)
データフレームから指定された列名一覧の列を選択する	df[columns]
日付データをn週間前に戻す	aDate - datetime.timedelta(weeks=n)
折れ線グラフを描画して、その色をピンクに設定する	plt.plot(データ列, データ列2, color='pink')
データフレームを10の位で丸める	df.round(-1)
折れ線グラフの三角マーカーを緑色にする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='g')
二つの文字列は等しいか確認する	s == s2
データフレームを二つの列の値によってまとめたグループ	df.groupby(['A', 'B'])
２つのカウンタの共通する要素を計算する	aCounter & aCounter2
実数から実数を引く	x - y
折れ線グラフの三角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='^', markersize=n)
nまでの偶整数列	list(range(2, n, 2))
データフレームのカラムの中にある文字列と文字列の合計を数える	df[col].isin([value, value2]).sum()
現在が何分か知る	datetime.date.today().minute
配列の全要素を指定の値にする	aArray[:, :] = 指定の値
リストを青色でプリントできる文字列に変換する	f'\033[34m{value}\033[0m'
ヒストグラムを描画して、その色をラベンダーブラッシュに設定する	plt.hist(データ列, color='lavenderblush')
データフレームのリスト列の欠損値を直後の値に設定する	df[aList].fillna(method='bfill')
リストとリストの散布図を描画して、左三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='<', c=rgb)
グラフの用途をポスターにする	sns.set(context='poster')
＜オプション＞エンコーディングをBOM付きに設定する	encoding = 'utf_8_sig'
データフレームの欠損値を中央値に設定する	df.fillna(df.median())
データフレームの欠損値を最小値で埋める	df.fillna(df.min())
線グラフを描画して、色を黄色くする	plt.plot(データ列, データ列2, color='y')
データ列と数列についての散布図に赤色の丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c='r')
データフレームを列名リストによって昇順にソートする	df.sort_values(by=column, ascending=True)
折れ線グラフの色を青くする	plt.plot(データ列, データ列2, color='b')
＜オプション＞グラフの色をカデットブルーに設定する	color = 'cadetblue'
ヒストグラムの色を青に設定する	plt.hist(データ列, color='blue')
折り返しを無効に設定する	pd.set_option('expand_frame_repr', False)
オブジェクトはリストの要素	element in aList
数値を紫色化する	f'\033[35m{value}\033[0m'
折れ線グラフの色をパールバイオレットレッドに指定する	plt.plot(データ列, データ列2, color='palevioletred')
ヒストグラムを描画して、その色を白に設定する	plt.hist(データ列, color='white')
カウンタをリストに変換する	list(aCounter)
データフレームの値が欠損値か調べる	df.isna()
オブジェクトがプロパティを持つか確認する	hasattr(obj, プロパティ名)
x,y,zをそれぞれn,n2,n3とする	x, y, z = n, n2, n3
＜オプション＞namesをカラムの名前に設定する	names = names
ヒストグラムを描画して、その色をダークゴールデンロッドに設定する	plt.hist(データ列, color='darkgoldenrod')
＜オプション＞アンティークホワイト色を使う	color = 'antiquewhite'
＜オプション＞ダークグリーン色を使う	color = 'darkgreen'
黄色いポイント印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='y')
タプルのコピーを作成する	aDict.copy()
データフレームのインデックスの名前をまとめて、nameからname2に付け直す	df.rename(index={name: name2})
折れ線グラフの色をローングリーンに設定する	plt.plot(データ列, データ列2, color='lawngreen')
データフレームの内で、列に重複があるか確認する	df.duplicated(subset=column)
折れ線グラフを描画してその色をミディアムバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='mediumvioletred')
ヒストグラムを描画して、その色を茶色にセットする	plt.hist(データ列, color='brown')
辞書から項目名の値	aDict.get(key)
ヒストグラムの色を茶色に設定する	plt.hist(データ列, color='brown')
＜オプション＞四角マーカーを使う	marker = 's'
グラフのデータラベルの位置を(x,y)に設定する	plt.legend(loc=(x, y))
データフレームの中央値	df.median()
数列とイテラブルの散布図に黒色の丸マーカーをプロットする	plt.plot(xdata, ydata, marker='o', c='k')
イテラブルを文字列リストに変換して、タブで連結する	'\t'.join(map(str, iterable))
値が集合に含まれないか調べる	element not in aSet
データフレームのリストカラムの欠損値を平均値で埋める	df[aList].fillna(df[aList].mean())
＜オプション＞グラフの色をシアンに指定する	color = 'cyan'
データフレームを各列と列の組み合わせ毎に集約し、平均値を算出する	df.groupby([column, column2], as_index=False).mean()
グラフに水平方向の破線を付ける	plt.axhline(y=0, linestyle='dashed')
データ列とリストについての散布図に黒色の星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='k')
ファイルを書き込みモードでオープンして]、fとする	f = open(filepath, mode='w')
データフレームの列をダミー変数に変換する	pd.get_dummies(df[column])
データフレームからランダムにn行を抽出する	df.sample(n)
時間を使う	import time
横棒を描いて、中央寄せする	plt.barh(ラベル列, データ列, align='center')
実数に実数を掛ける	x * y
スチールブルー色のヒストグラムを描画する	plt.hist(データ列, color='steelblue')
ベクトルの行列式	np.linalg.det(aArray)
マルーン色のヒストグラムを描画する	plt.hist(データ列, color='maroon')
パステル調のグラフの色を黒くする	plt.plot(xdata, ydata, linestyle='pastel', color='k')
実数が正の数か調べる	x > 0
ファイルをUTF8で書き込み用にオープンする]	open(filepath, mode='w', encoding='utf-8')
ヒストグラムを描画して、その色をダーク・スラテグレーに設定する	plt.hist(データ列, color='darkslategrey')
データフレームの列の値がxでない行をフィルタする	df[df[column] == x]
線グラフを描画してその色をダークサーモンに設定する	plt.plot(データ列, データ列2, color='darksalmon')
暗い色を用いてヒストグラムを描画する	plt.hist(xdata, color='dark')
データ列の欠損値を平均値に設定する	ds.fillna(ds.mean())
＜オプション＞ライトブルー色を用いる	color = 'lightblue'
カラーコードの右三角マーカーで散布図をプロットする	plt.plot(xdata, ydata, marker='>', c=rgb)
二変数の最も大きい値を計算する	max(x, y)
＜オプション＞グラフの色を珊瑚に変更する	color = 'coral'
本日の日付	datetime.date.today()
整数nがセットのどれかか調べる	n in aSet
イエローグリーン色のヒストグラムを描画する	plt.hist(データ列, color='yellowgreen')
マップにキーワード引数で更新する	aDict.update(**kwargs)
淡いを描画し、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
＜オプション＞グラフの色をディープスカイブルーに設定する	color = 'deepskyblue'
線グラフを描画して色をホットピンクに設定する	plt.plot(データ列, データ列2, color='hotpink')
文字列にシーケンスを変換して、部分文字列で連結する	sub.join(map(str, iterable))
リストを青色化する	f'\033[34m{value}\033[0m'
小数点数がNaNかどうか調べる	math.isnan(x)
リストとリストについての散布図にカラーコードのクロスマーカーを描く	plt.plot(xdata, ydata, marker='x', c=rgb)
文字列は全て十進数字か調べる	s.isdecimal()
配列を等量でn個にビン分割する	pd.qcut(aArray, n)
行列の値を変更する	aArray[行番号, 列番号] = 指定の値
リストとリストの青い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='b')
リストとリストについての散布図に丸マーカーを描画する	plt.plot(xdata, ydata, marker='o')
散布図を黒い星マーカーを用いて描画する	plt.plot(xdata, ydata, marker='*', c='k')
淡いの折れ線グラフの色をカラーコードに変更する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
バイナリ書き込みできるようにファイルをオープンする]	open(filepath, mode='wb')
破壊的にデータフレームを二つの列によってでソートする	df.sort_values(by=['A', 'B'], inplace=True)
グレー色の線グラフを描画する	plt.plot(データ列, データ列2, color='gray')
折れ線グラフの色をライトグリーンに指定する	plt.plot(データ列, データ列2, color='lightseagreen')
FIXME:カテゴリーデータを出現頻度順にソートする	df['A'].value_counts().sort_index().index
データ列の未入力値を最大値に設定する	ds.fillna(ds.max())
ヒストグラムを描画して、その色をスカイブルーに設定する	plt.hist(データ列, color='skyblue')
＜オプション＞ホワイトスモークにグラフの色を設定する	color = 'whitesmoke'
＜オプション＞グラフの色をグリーンイエローに変更する	color = 'greenyellow'
文字列の中で大文字・小文字を無視して正規表現にマッチした全ての文字列をリストに変換する	re.findall(pattern, s, flags=re.IGNORECASE)
エクセルファイルファイルから複数のシートを読み込む	pd.read_excel(filename, sheet_name=[n, n2])
常用対数	math.log10(x)
データ列の中央値	ds.median()
リストとイテラブルについて散布図を描画し、マーカーを三角に設定する	plt.plot(xdata, ydata, marker='^')
文字列をセンタリングにする	s.center(文字列幅)
＜オプション＞データ型を指定する	dtype = bool
折れ線グラフのポイントマーカーの大きさをnに変更する	plt.plot(データ列, データ列2, marker='.', markersize=n)
日付時刻データと日付時刻データの時間差を秒数で求める	(aDatetime - aDatetime2).total_seconds()
＜オプション＞シスルにグラフの色を設定する	color = 'thistle'
整数をゼロ埋めした文字列に変換する	str(n).zfill(文字列幅)
＜オプション＞BOM付きを使う	encoding = 'utf_8_sig'
各列毎にデータフレームをグループ化して、列の最大値を求める	df.groupby(column)[column2].max()
グラフのカラーパレットを明るくする	sns.set(pallete='bright')
改行なしに２つの文字列をプリントする	print(value, value2, end='')
二つのデータフレームを結合する	pd.merge(df, df2)
折れ線グラフの色をパープルに設定する	plt.plot(データ列, データ列2, color='purple')
ヒストグラムを破線で描画する	plt.hist(データ列, linestyle='dashed')
二つのデータフレームを列'A'と列'B'をキーとして全結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='outer')
ファイルを文字コードtextで書き込み用にオープンする]	open(filepath, mode='w', encoding=text)
スピアマン相関係数でデータフレームの列と列の相関行列	df[[column, column2]].corr(method='spearman')
ヒストグラムを描画して、色をコーンフラワーブルーに指定する	plt.hist(データ列, color='cornflowerblue')
＜オプション＞ライトグレー色を使用する	color = 'lightgrey'
データフレームを列によってソートし、、インデックスを振り直す	df.sort_values(columns).reset_index(drop=True)
線グラフを描画して、その色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategray')
nとn2の論理和	n | n2
イテラブルとデータ列についての散布図にカラーコードのダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D', c=rgb)
オプションで標準出力を用いる	file = sys.stdout
横棒をプロットして、中央寄せする	plt.barh(ラベル列, データ列, align='center')
データフレームのn行目を抽出する	df.loc[n]
英文字からひとつランダムに選ぶ	random.choice(string.ascii_uppercase)
リストをn倍する	aList * n
リストと配列の青い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='b')
リストの最後	aList[-1]
データ列のヒストグラムを描画する	plt.hist(ds)
折れ線グラフを描画してその色をダークオリーブグリーンに設定する	plt.plot(データ列, データ列2, color='darkolivegreen')
データフレームのカラムのpercentパーセンタイル	df[col].quantile(percent/100)
ヒストグラムを描画して、色をディムグレーに指定する	plt.hist(データ列, color='dimgray')
オブジェクトは関数	callable(obj)
グラフの色を全般的に明るくする	sns.set(pallete='bright')
データフレームの欠損値を最大値で置き換える	df.fillna(df.max())
散布図にポイントマーカーを使う	plt.plot(xdata, ydata, marker='.')
折れ線グラフに緑色のポイントマーカーを描画する	plt.plot(データ列, データ列2, marker='.', markerfacecolor='g')
ホットピンク色の線グラフを描画する	plt.plot(データ列, データ列2, color='hotpink')
データフレームから重複ありでランダムにn行をサンプリングする	df.sample(n, replace=True)
整数nを八進数文字列にする	oct(n)[2:]
データフレームを列で並べて、行を振り直す	df.sort_values(columns).reset_index(drop=True)
オブジェクトはリストクラス	isinstance(obj, list)
データ列を等間隔でn個にビン分割する	pd.cut(ds, n)
エクセルファイルファイルからnという名前のシートをデータフレームとして読み込む	pd.read_excel(filename, sheet_name=n)
文字列はタイトルケース	s.istitle()
＜オプション＞グラフの色をアイボリーにセットする	color = 'ivory'
セットをイミュータブルな集合に変換する	frozenset(aSet)
＜オプション＞ナバホホワイト色を使う	color = 'navajowhite'
リストをプリントする	print(value)
データフレームの欠損値を最大値に設定する	df.fillna(df.max())
サドルブラウン色の線グラフを描画する	plt.plot(データ列, データ列2, color='saddlebrown')
データフレームの列と列の相関行列ケンドール相関係数でを計算する	df[[column, column2]].corr(method='kendall')
＜オプション＞グラフの色をローングリーンに設定する	color = 'lawngreen'
折れ線グラフのスタイルを実線に設定する	plt.plot(データ列, データ列2, linestyle='solid')
日付データをn時間前に戻す	aDate - datetime.timedelta(hours=n)
データフレームを各列と列の組み合わせ毎にグループ化して、個数を求める	df.groupby([column, column2], as_index=False).count()
ヒストグラムを描画して、その色をグリーンに設定する	plt.hist(データ列, color='green')
＜オプション＞インディゴ色を使う	color = 'indigo'
ダークグレー色のヒストグラムを描画する	plt.hist(データ列, color='darkgray')
データフレームのカラムと列に重複があれば、マスクする	df.duplicated(subset=[column, column2])
＜オプション＞グラフの色をインディゴに変更する	color = 'indigo'
文字列を白色でプリントする	print(f'\033[37m{value}\033[0m')
ファイルの拡張子なしのファイル名を見る	os.path.splitext(os.path.basename(filepath))[0]
データ列の欠損値を最小値に設定する	ds.fillna(ds.min())
数列とリストの黒い明るいを描画する	plt.plot(xdata, ydata, linestyle='bright', color='k')
列の値でデータフレームをグループ化し、、それぞれのグループの件数を知る	df.groupby(column).size()
＜オプション＞フォレストグリーン色を使用する	color = 'forestgreen'
実数のk進対数	math.log(x, k)
項目名が辞書に存在しないとき、要素を追加する	aDict.setdefault(key, element)
データフレームのリストカラムの未入力値を最小値で置き換える	df[aList].fillna(df[aList].min())
ヒストグラムを描画して、その色をパールバイオレットレッドに設定する	plt.hist(データ列, color='palevioletred')
＜オプション＞紺碧色を使用する	color = 'azure'
二つの集合の差集合を算出する	aSet.difference(aSet2)
散布図をカラーコードの四角マーカーとして描画する	plt.plot(xdata, ydata, marker='s', c=rgb)
折れ線グラフに線幅nのクロス印を描画する	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
ファイルをEUCでオープンする]	open(filepath, encoding='euc_jp')
折れ線グラフの左三角マーカーの線幅をnに変更する	plt.plot(データ列, データ列2, marker='<', markeredgewidth=n)
リストとリストについての散布図に三角マーカーを描画する	plt.plot(xdata, ydata, marker='^')
マッピングのの一覧	aDict.values()
列の各要素に対して、predicateFuncの適用が真であれば、その要素を出力する	itertools.takewhile(predicateFunc, iterable)
スプリンググリーン色のヒストグラムを描画する	plt.hist(データ列, color='springgreen')
＜オプション＞シアンにグラフの色を変更する	color = 'cyan'
３つのデータフレームを横向きに合体させる	pd.concat([df, df2, df3], axis=1)
配列を等量でビン数nでビン分割する	pd.qcut(aArray, n)
スラグレー色のヒストグラムを描画する	plt.hist(データ列, color='slategrey')
カウンタのそれぞれの文字列をそのカウントだけリストとして得る	aCounter.elements()
ヒストグラムを描画して、その色をミディアムスレートブルーに設定する	plt.hist(データ列, color='mediumslateblue')
nとn2の排他的論理和	n ^ n2
データ列の中にある文字列の合計を数える	ds.isin([value]).sum()
Pandasのバージョンを見る	print(pd.__version__)
折れ線グラフに黒い大バツマーカーを描画する	plt.plot(データ列, データ列2, marker='X', markerfacecolor='k')
データ列をヒストグラムで可視化する	plt.hist(ds)
淡いグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='muted', color='k')
ゼロ埋めされた複素数型の配列	np.zeros(要素数, dtype=bool)
線グラフを描画して、色を青くする	plt.plot(データ列, データ列2, color='b')
ファイルパスを追加モードを使ってオープンする]	open(filepath, mode='a')
実数を文字列に変換する	str(x)
日付時刻データが月曜日か確認する	aDatetime.weekday() == 0
ヒストグラムを描画して、その色をコーラルにセットする	plt.hist(データ列, color='coral')
グラフの色使いを色差別なくする	sns.set(pallete='colorblind')
文字列の末尾から部分文字列を探す	s.rfind(sub)
データ列のpercent分位数	ds.quantile(percent/100)
双方向キューのstart番目からendの要素	collections.deque(itertools.islice(deq, start, end))
全要素を０で初期化された複素数型の行列	np.zeros(行数, 列数, dtype=bool)
＜オプション＞コロンをセパレータで使用する	sep = ':'
＜オプション＞色をプラムに設定する	color = 'plum'
グラフのフォントを日本語表示に設定する	sns.set(font='IPAexGothic')
折れ線グラフの色をミディアムシアグリーンに設定する	plt.plot(データ列, データ列2, color='mediumseagreen')
＜オプション＞ダークブルー色を使用する	color = 'darkblue'
プロットの色を淡くする	sns.set(pallete='muted')
ヒストグラムを描画して、その色を青紫に設定する	plt.hist(データ列, color='violet')
＜オプション＞ライムグリーン色を使う	color = 'limegreen'
xのハッシュ値	hash(x)
リストとリストの折れ線グラフを描画して、透明度をalphaに設定する	plt.plot(xdata, ydata, alpha=alpha)
データフレームの中の欠損値の合計を数える	df.isna().sum()
＜オプション＞グラフの色を赤に設定する	color = 'red'
ピーチパフ色の線グラフを描画する	plt.plot(データ列, データ列2, color='peachpuff')
ファイルからディレクトリ名を使う	os.path.dirname(filepath)
表示可能な列数の最大値をnに変更する	pd.set_option('display.max_columns', n)
配列を2次元1行に変形する	aArray.reshape(1, -1)
文字列の開始位置番目からと終了位置番目までの間に部分文字列が含まれないかどうか	s.find(sub, start, end) == -1
折れ線グラフの四角印を赤色にする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='r')
データフレームを1000の位で丸めて整数型にする	df.round(-3).astype(int)
エポック秒から日付時刻に変換する	datetime.datetime.fromtimestamp(timestamp)
文字列の長さ	len(s)
文字列を左トリムする	s.lstrip()
プログラムのファイルの名前	sys.argv[0]
リストと配列の散布図を淡い色で描画する	plt.plot(xdata, ydata, c='muted')
リストの各値を関数に適用した結果で並べる	sorted(aList, key=func)
赤い左三角マーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='<', c='r')
文字列を別の文字列で置き換える	s.replace(sub, newsub)
＜オプション＞ダークオリーブグリーンに色をセットする	color = 'darkolivegreen'
ヒストグラムを描画して、その色をペールグリーンに設定する	plt.hist(データ列, color='palegreen')
辞書からキーで指定された項目を取り出す	aDict.pop(key)
片仮名を平仮名にする	''.join([chr(ord(ch) - 96) if ('ァ' <= ch <= 'ン') else ch for ch in s])
0からnまでのスライス	slice(n)
ライトスチールブルー色のヒストグラムを描画する	plt.hist(データ列, color='lightsteelblue')
配列を分割数nでビン分割する	pd.cut(aArray, n)
データフレームのリストカラムの最頻値	df[aList].mode()
データフレームのリストカラムの中に日付データと日付データがいくつ含まれるか数える	df[aList].isin([value, value2]).sum()
データ列を1000の位で丸める	ds.round(-3)
日付データををn週間後に進める	aDate + datetime.timedelta(weeks=n)
配列とイテラブルの色差別ないグラフを描いて、その色を青にする	plt.plot(xdata, ydata, linestyle='colorblind', color='b')
パステル調のグラフの色をカラーコードに設定する	plt.plot(xdata, ydata, linestyle='pastel', color=rgb)
データフレームのカラムの欠損値を直後の値で埋める	df[col].fillna(method='bfill')
エクセルファイルファイルからnとn2のシートを読み込む	pd.read_excel(filename, sheet_name=[n, n2])
折れ線グラフを描画して、その色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgrey')
グラフのカラーパレットを淡くする	sns.set(pallete='muted')
ふたつの集合の共通要素だけにする	aSet.intersection_update(aSet2)
日付データが土曜日か調べる	aDate.weekday() == 5
ペルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='peru')
オーキッドにヒストグラムの色を設定する	plt.hist(データ列, color='orchid')
＜オプション＞グラフの色をライトブルーに設定する	color = 'lightblue'
データフレームを'A'列によってソートする	df.sort_values(by='A')
ファイルパスを書き込みできるように開く]	open(filepath, mode='w')
＜オプション＞パールゴールデンロッド色を使う	color = 'palegoldenrod'
リストと数列のパステル調のグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
組の末尾を取り除く	aTuple[:-1]
二つのリストから辞書	dict(zip(aList, aList2))
綺麗なグラフを使う準備をする	import seaborn as sns
ヒストグラムの色をパレットトルコイズに指定する	plt.hist(データ列, color='paleturquoise')
両端キューの中に値が含まれてるか調べる	element in deq
データフレームから指定された三つの列を取り出す	df[[column, column2, column3]]
日付データを文字列でフォーマットして文字列に変換する	"aDate.strftime(""%d/%m/%y"")"
データ列の欠損値を最大値で埋める	ds.fillna(ds.max())
データ列の標準偏差を算出する	ds.std()
＜オプション＞エンコーディングをSJISに設定する	encoding = 'shift_jis'
辞書の項目数	len(aDict)
タプルのキーの一覧	aDict.keys()
マッピングの項目を列挙する	aDict.values()
ファイルパスの拡張子付きのファイル名を求める	os.path.basename(filepath)
小数点数のハイパボリック・コサインの逆数	math.acosh(x)
インディゴ色の線グラフを描画する	plt.plot(データ列, データ列2, color='indigo')
折れ線グラフの色をイエローグリーンに設定する	plt.plot(データ列, データ列2, color='yellowgreen')
緑色の右三角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='g')
重複していない行のみを抽出する	df[not df.duplicated(keep=False)]
集合の補集合	aSet.difference(aSet2)
配列を等量で分割数nでビン分割する	pd.qcut(aArray, n)
データフレームの列を文字列にリネームする	df.rename(columns={column: name})
八進文字列をバイト列に変換する	int(s, 8).to_bytes(length=bytesize, byteorder='big')
数値の符号を同じにする	math.copysign(x, x2)
二つの列でデータフレームをグループ化し、記述統計量を算出する	df.groupby(['A', 'B']).describe()
オプションで標準エラーを用いる	file = sys.stderr
＜オプション＞色をタンに指定する	color = 'tan'
二次元リストをフラット化する	sum(aList)
左にn個分キューの要素をローテンションする	deq.rotate(-n)
折れ線グラフのダイアモンド印を青色にする	plt.plot(データ列, データ列2, marker='D', markerfacecolor='b')
データフレームの列の値がx以下の行を抽出する	df[df[column] <= x]
ヒストグラムの色を白に設定する	plt.hist(データ列, color='white')
ヒストグラムの色を青紫に設定する	plt.hist(データ列, color='violet')
ディープスカイブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='deepskyblue')
CSVTSVファイルをn番目のカラムをインデックスとして読み込む	pd.read_csv(filename, index_col=n)
データ列のユニークな値	ds.unique()
ファイルをEUCとして開く]	open(filepath, encoding='euc_jp')
リストをヒストグラムとして可視化する	plt.hist(aList)
文字列を白色にする	f'\033[37m{value}\033[0m'
リストとリストについて青色の明るいグラフを描く	plt.plot(xdata, ydata, linestyle='bright', color='b')
２つの文字列をカンマで区切ってプリントする	print(value, value2, sep=',')
TSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t')
データフレームを列によってグループ化して、それぞれのグループごとの平均値を求める	df.groupby(column).mean()
紺碧色の線グラフを描画する	plt.plot(データ列, データ列2, color='azure')
折れ線グラフを描画してその色をラベンダーブラッシュに指定する	plt.plot(データ列, データ列2, color='lavenderblush')
スラッシュで区切って二つの文字列を出力する	print(value, value2, sep='/')
＜オプション＞ゴールデンロッドに色を指定する	color = 'goldenrod'
日付時刻データをタプルに変換する	aDatetime.timetuple()
色差別ないグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
棒グラフの色をカラーコードに指定する	plt.bar(ラベル列, データ列, color=rgb)
データフレームのカラムの欠損値を中央値で埋める	df[col].fillna(df[col].median())
＜オプション＞ディムグレー色を使う	color = 'dimgray'
グラフで使うカラーパレットをpalleteNameに設定する	sns.set(pallete=palleteName)
二つの文字列をケースを無視して比較する	s.casefold() < s2.casefold()
スクリプトのファイル名	sys.argv[0]
リストを横軸と指定して、折れ線グラフを描画する	plt.plot(range(len(xdata)), xdata)
日付時刻データをISO形式の文字列に変換する	aDatetime.isoformat()
折れ線グラフを描画して、色を赤くする	plt.plot(データ列, データ列2, color='r')
オブジェクトはタプルクラスかどうか調べる	isinstance(obj, tuple)
nがn2以下か調べる	n <= n2
＜オプション＞デピンク色を使う	color = 'deeppink'
折れ線グラフを描画して、色を紺碧にセットする	plt.plot(データ列, データ列2, color='azure')
データフレームを列でソートし、、上位n件を取り出す	df.sort_values(columns).head(n)
イテラブルのセット	set(iterable)
＜オプション＞ライトグリーン色を使う	color = 'lightgreen'
ヒストグラムの色をハニーデューに設定する	plt.hist(データ列, color='honeydew')
＜オプション＞色をオリベドラブにする	color = 'olivedrab'
ヒストグラムを描画して、その色をアクアマリンに指定する	plt.hist(データ列, color='aquamarine')
データフレームを列名リストで昇順にソートして更新する	df.sort_values(by=column, ascending=True, inplace=True)
nがn2より小さい	n < n2
Pandasで、データ列のエポック秒からPandasの日付型に変換する	pd.to_datetime(ds, unit='s', utc=True)
折れ線グラフの色を白くする	plt.plot(データ列, データ列2, color='w')
線グラフを描画して、色をイエローグリーンに変更する	plt.plot(データ列, データ列2, color='yellowgreen')
データ列の正規分布に対する左右対称性	ds.kurt()
データフレームを欠損値を含めて列の値でグループ化する	df.groupby(column, dropna=False)
＜オプション＞グラフの色をパウダーブルーに設定する	color = 'powderblue'
リストと数列についての散布図を淡い色で重なりを見やすくプロットする	plt.plot(xdata, ydata, c='muted', alpha=0.5)
既存の配列を元に全要素が0の配列	np.zeros_like(aArray)
データフレームの中で、列と列の重複を見る	df.duplicated(subset=[column, column2])
二つのデータ列を並べて箱ひげ図にする	plt.boxplot([データ列, データ列2])
データフレームのカラムは何月か見る	df[col].dt.month
＜オプション＞三角印を使う	marker = '^'
ダークシアン色のヒストグラムを描画する	plt.hist(データ列, color='darkcyan')
イテラブルを集合に追加する	aSet.update(iterable)
＜オプション＞ライム色を使う	color = 'lime'
配列のユニークな要素とその位置	u, indices = np.unique(aArray, return_index=True)
実数の指数	math.frexp(x)[1]
折れ線グラフの星マーカーの線幅をnに変更する	plt.plot(データ列, データ列2, marker='*', markeredgewidth=n)
＜オプション＞暗い赤を使う	color = 'darkred'
＜オプション＞ピーチパフ色を使う	color = 'peachpuff'
二つのオブジェクトが同じ参照	obj is obj2
線グラフの色をスチールブルーに設定する	plt.plot(データ列, データ列2, color='steelblue')
配列とリストについて散布図を描画して、マーカーをバツに設定する	plt.plot(xdata, ydata, marker='x')
文字列をISO書式として日付時刻に変換する	datetime.datetime.fromisoformat(日付の書かれた文字列)
＜オプション＞紺にグラフの色を設定する	color = 'darkblue'
イテラブルを2回あわせた直積	itertools.product(iterable, repeat=2)
二つのカウンタの共通する要素	aCounter & aCounter2
データ列の中にいくつ文字列が存在するか数える	ds.isin([value]).sum()
＜オプション＞コーンズシルク色を用いる	color = 'cornsilk'
整数nが集合のどれかかどうか調べる	n in aSet
配列と同じ大きさの空行列を初期化する	np.empty_like(aArray)
プロットの描画でパステル調のパレットを使う	sns.set(pallete='pastel')
＜オプション＞グラフの色をグリーンに設定する	color = 'green'
データフレームの欠損値をxで埋める	df.fillna(x)
＜オプション＞グラフの色をシーグリーンにする	color = 'seagreen'
データフレームから型リストデータ型の列を抽出する	df.select_dtypes(include=typeList)
データフレームを各列毎にグループ化して、列の最小値を求める	df.groupby(column)[column2].min()
文字列中にひとつでも非空白が含まれるか調べる	any(not c.isspace() for c in s)
データ列の値をreplに正規表現patternでまとめて置き換える	ds.replace(pattern, repl, regex=True)
ヒストグラムの色をフローラルホワイトに設定する	plt.hist(データ列, color='floralwhite')
折れ線グラフを描画して、その色をダークバイオレットに設定する	plt.plot(データ列, データ列2, color='darkviolet')
＜オプション＞改行をセパレータで使う	sep = '\n'
xを文字列に変換する	str(x)
ふたつの集合の和集合	aSet.union(aSet2)
コマンドライン引数	sys.argv
predicateFuncがTrueとなるイテラブルの部分	itertools.takewhile(predicateFunc, iterable)
ヒストグラムを描画してその色をダークシアグリーンに設定する	plt.hist(データ列, color='darkseagreen')
列の各値が何回出現するか見る	df[col].value_counts()
ビン数nの柱状図をプロットする	plt.hist(データ列, bins=n)
＜オプション＞ライトゴールドロディイエロー色を使う	color = 'lightgoldenrodyellow'
データフレームのリストカラムのメディアン	df[aList].median()
データフレームの内で、列と列の重複を落とす	df.drop_duplicates(subset=column)
ファイルを読み込みできるようにオープンする]	open(filepath, mode='r')
リストの最後の値	aList[-1]
散布図を暗い色のマーカーで描画する	plt.plot(xdata, ydata, c='dark')
アルファベットの小文字を全部見る	string.ascii_lowercase
JSON文字列をデータにする	json.loads(jsonString)
データフレームのどの値が最も現れるか見る	df.mode()
数値を紫色でプリントできる文字列に変換する	f'\033[35m{value}\033[0m'
日付データの日を使う	aDate.day
＜オプション＞読み込むシートの名前をnamesに設定する	sheet_name = names
線グラフを描画して、その色をダークグレーに設定する	plt.plot(データ列, データ列2, color='darkgrey')
折れ線グラフのバツマーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='x', markersize=n)
折れ線グラフにクロスマーカーを用いる	plt.plot(データ列, データ列2, marker='x')
ヒストグラムの色をカーキに変更する	plt.hist(データ列, color='khaki')
リストとリストについて散布図を描画して、バツマーカーの色をカラーコードに指定する	plt.plot(xdata, ydata, marker='x', c=rgb)
マッピングの項目名とその値を列挙する	aDict.items()
データフレームのカラムが何秒か確認する	df[col].dt.second
nからn2までのstepごとによるスライス	slice(n, n2, step)
データ列の欠損値を直後の値に変更する	ds.fillna(method='bfill')
三つのデータフレームを横向きに連結する	pd.concat([df, df2, df3], axis=1)
＜オプション＞色をオリベドラブに変更する	color = 'olivedrab'
リストと配列の散布図を明るい色を用いて重なりを見やすく描画する	plt.plot(xdata, ydata, c='bright', alpha=0.5)
文字列は全て印字できるか調べる	s.isprintable()
黒い上三角マーカーを使って散布図を描画する	plt.plot(xdata, ydata, marker='^', c='k')
データフレームを'A'列をキーにして並べる	df.sort_values(by='A')
分子n分母mの分数を作成する	fractions.Fraction(numerator=n, denominator=m)
ケースを無視して文字列全体をパターンにマッチさせる	re.fullmatch(pattern, s, flags=re.IGNORECASE)
データフレームのリスト列は正規分布からどれだけ歪んでいるか見る	df[aList].kurt()
列をセットに追加する	aSet.update(iterable)
＜オプション＞グラフの色をサンディーブラウンに設定する	color = 'sandybrown'
ファイルパスの拡張子付きのファイル名	os.path.basename(filepath)
イテラブルと数列について散布図を描画して、星マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='*', c=rgb)
本日が水曜日か調べる	datetime.datetime.today().weekday() == 2
線グラフを描画してその色をミッドナイトブルーに設定する	plt.plot(データ列, データ列2, color='midnightblue')
データフレームを列によって並べ直してNaNを先頭にする	df.sort_values(by=column, na_position='first')
データ列の中にいくつ文字列があるか求める	ds.isin([value]).sum()
文字列を最後の部分文字列で分割したときの後半の文字列	s.rpartition(sub)[-1]
＜オプション＞グラフの色をダークゴールデンロッドにセットする	color = 'darkgoldenrod'
タプルの平均値	sum(aTuple)/len(aTuple)
データフレームからn番目の列を除く	pd.concat([df[df.columns[:n]], df[df.columns[n+1:]]], axis=1)
日付データをn秒前に戻す	aDate - datetime.timedelta(seconds=n)
ヒストグラムを描画して、その色をモカシンに設定する	plt.hist(データ列, color='moccasin')
折れ線グラフを描画して、色をゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='goldenrod')
データフレームを複数の列をキーにして整列する	df.sort_values(by=column)
データ列と配列についての散布図に右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>')
データフレームの列と列の相関行列ピアソンとしてを計算する	df[[column, column2]].corr(method='pearson')
ライトスカイブルー色のヒストグラムを描画する	plt.hist(データ列, color='lightskyblue')
＜オプション＞ライトシアン色を使用する	color = 'lightcyan'
折れ線グラフを描画して、その色を耐火レンガに設定する	plt.plot(データ列, データ列2, color='firebrick')
ローングリーン色の線グラフを描画する	plt.plot(データ列, データ列2, color='lawngreen')
正規分布で疑似乱数を生成する	random.normalvariate(mu=0.5, sigma=0.2)
列を等間隔でn個にビン分割する	pd.cut(ds, n)
＜オプション＞マーカーをポイントに変更する	marker = '.'
実数が正の数	x > 0
SJISでファイルをオープンする]	open(filepath, encoding='shift_jis')
線グラフを描画して、その色をインディアンレッドに変更する	plt.plot(データ列, データ列2, color='indianred')
文字列全体が正規表現に大文字・小文字を無視してマッチするか見る	re.fullmatch(pattern, s, flags=re.IGNORECASE)
プロットの色をパステル調にする	sns.set(pallete='pastel')
実数を小数点第一位で丸める	round(x, 1)
事前にASCII限定として正規表現をコンパイルする	re.compile(pattern, flag=re.ASCI)
本日の年数	datetime.datetime.today().year
現在が何年か知る	datetime.datetime.today().year
データフレームのカラムのNaNを最大値で埋める	df[col].fillna(df[col].max())
日付データにn秒分、加算する	aDate + datetime.timedelta(seconds=n)
折れ線グラフに△マーカーを使う	plt.plot(データ列, データ列2, marker='^')
データフレームのカラムの中にいくつ欠損値があるか数える	df[col].isna().sum()
n個に列を分割し、、namesのラベルをつける	pd.cut(ds, n, labels=names)
文字列の末尾からタブを取り除く	s.rstrip('\t')
数列とリストについての散布図に丸マーカーを描く	plt.plot(xdata, ydata, marker='o')
ビン数nでデータフレームの中の列を分割する	pd.cut(df[col], n)
データフレームからn行、サンプリングする	df.sample(n)
配列とデータ列の散布図を描画して、マーカーの色を暗いに設定する	plt.plot(xdata, ydata, c='dark')
ヒストグラムを描画して、その色をアクアマリンに設定する	plt.hist(データ列, color='aquamarine')
データフレームのリストカラムの標本標準偏差	df[aList].std()
イテラブルの移り変わりを折れ線で描画する	plt.plot(range(len(xdata)), xdata)
JSONフォーマットの文字列をデータに変換する	json.loads(jsonString)
nを切り捨てながらn2分の一にする	n //= n2
ヒストグラムの色をシーグリーンに設定する	plt.hist(データ列, color='seagreen')
変数がマイナス無限大に近づくときの数式の極限値を求める	sympy.limit(e, z, -oo)
カラーコードのダイアモンドマーカーを散布図に用いる	plt.plot(xdata, ydata, marker='D', c=rgb)
＜オプション＞プラム色を使用する	color = 'plum'
カラムの空文字をNaNに変換し、ドロップする	ds.replace('', np.nan).dropna()
列によってデータフレームを小さい順に破壊的に並べ直す	df.sort_values(by=column, ascending=True, inplace=True)
折れ線グラフを描画して、その色をライトスチールブルーに設定する	plt.plot(データ列, データ列2, color='lightsteelblue')
二つのデータフレームを列'A'と列'B'をキーとして内部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
実数のn乗	pow(x, n)
部分文字列で部分文字列が始まる	s.startswith(sub)
＜オプション＞グラフの色をライトスレイグレーに設定する	color = 'lightslategray'
プロットの見栄えをデフォルトでいい感じに設定する	sns.set()
ヒストグラムの色をコーンフラワーブルーに指定する	plt.hist(データ列, color='cornflowerblue')
リストとリストについての散布図に赤い丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c='r')
実行を正しく止める	sys.exit(0)
配列の平均値	np.mean(aArray)
＜オプション＞左三角マーカーを描画する	marker = '<'
ミッドナイトブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='midnightblue')
複数カラムの散布図を一度にプロットする	sns.pairplot(df[[column, column2, column3]])
リストとデータ列で淡いの折れ線を描画してその線幅をnに指定する	plt.plot(xdata, ydata, linestyle='muted', color='r')
データフレームのカラムの中にいくつ文字列があるか数える	df[col].isin([value]).sum()
散布図に赤いダイアモンドマーカーを使う	plt.plot(xdata, ydata, marker='D', c='r')
ヒストグラムを描画してその色を茶色に変更する	plt.hist(データ列, color='brown')
折れ線グラフを描画して、その色をナバホホワイトに設定する	plt.plot(データ列, データ列2, color='navajowhite')
データフレームの欠損値を平均値に設定する	df.fillna(df.mean())
シーケンスのイミュータブルな集合を作る	frozenset(iterable)
＜オプション＞文字列をセパレータで使う	sep = s
＜オプション＞スカイブルー色を使う	color = 'skyblue'
グラフを論文用に変更する	sns.set(context='paper')
ゼロ埋めされたブール型のベクトル	np.zeros(要素数, dtype=np.int32)
データフレームを複数の列の値によってグループ化し、要約統計量を求める	df.groupby(columns).describe()
折れ線グラフを描画してその色をホットピンクに設定する	plt.plot(データ列, データ列2, color='hotpink')
リストとリストの色差別ないグラフを描画して、その色を黒にする	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
ファイルをバイナリ書き込みできるようにオープンする]	open(filepath, mode='wb')
＜オプション＞グラフの色をダークスレートブルーに指定する	color = 'darkslateblue'
パステル調の色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
赤い三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='^', c='r')
赤い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='r')
Pandasでエポック秒のデータフレームのcollからタイムスタンプ型にする	pd.to_datetime(df[col], unit='s', utc=True)
配列とリストの折れ線グラフを描画し、、untitledとラベル付けする	plt.plot(xdata, ydata, label=untitled)
ふたつの集合のいずれか一方だけの集合	aSet.symmetric_difference(aSet2)
実数以上の最小の整数	math.ceil(x)
双方向キューをポップする	deq.pop()
整数nのビット長を調べる	n.bit_length()
折れ線グラフを描画して、その色をライムに設定する	plt.plot(データ列, データ列2, color='lime')
折れ線グラフの四角マーカーのサイズをnに設定する	plt.plot(データ列, データ列2, marker='s', markersize=n)
集合から要素を全て取り除く	aSet.clear()
折れ線グラフを描画してその色をダークグリーンに設定する	plt.plot(データ列, データ列2, color='darkgreen')
カウンタをイテラブルで更新する	aCounter.update(iterable)
折れ線グラフの色をオーキッドに設定する	plt.plot(データ列, データ列2, color='orchid')
ヒストグラムの色をレベッカパープルに変更する	plt.hist(データ列, color='rebeccapurple')
分割数nでリストを等量でビン分割する	pd.qcut(aList, n)
タプルとイテラブルをペアリングする	itertools.zip_longest(iterable, iterable2)
リストの先頭	aList[0]
文字列のケースを入れ替える	s.swapcase()
ファイルパスをUTF8で書き込み用にオープンする]	open(filepath, mode='w', encoding='utf-8')
文字列の終了位置より前に部分文字列が含まれないかどうかテストする	s.find(sub, 0, end) == -1
文字列の全角数字を半角数字に変換する	s.translate(str.maketrans('０１２３４５６７８９', '0123456789'))
xの小数点以下'5'桁までをプリントする	print(':.5f'.format(x))
データフレームのリストカラムを丸めて、整数型にする	df[aList].round().astype(int)
ヒストグラムを描画してその色を青に変更する	plt.hist(データ列, color='blue')
赤い四角マーカーをイテラブルとイテラブルについての散布図に描画する	plt.plot(xdata, ydata, marker='s', c='r')
ダークスレートブルーにヒストグラムの色を設定する	plt.hist(データ列, color='darkslateblue')
折れ線グラフを描画して、その色をパパイヤウィップに設定する	plt.plot(データ列, データ列2, color='papayawhip')
キーが辞書に存在しないとき、要素を追加する	aDict.setdefault(key, element)
ヒストグラムの色をディムグレーに設定する	plt.hist(データ列, color='dimgray')
黒い▽マーカーを散布図に使う	plt.plot(xdata, ydata, marker='v', c='k')
黒いポイントマーカーとして散布図を描画する	plt.plot(xdata, ydata, marker='.', c='k')
列によってで破壊的にデータフレームを並べる	df.sort_values(by=column, inplace=True)
サドルブラウン色のヒストグラムを描画する	plt.hist(データ列, color='saddlebrown')
文字列のの開始位置から終了位置までの間に部分文字列がいくつか含まれるか調べる	s.count(sub, start, end)
データフレームを表示するとき、表示可能な最大列数を変更する	pd.set_option('display.max_columns', n)
折れ線グラフの色をホワイトスモークに設定する	plt.plot(データ列, データ列2, color='whitesmoke')
日付時刻データにn日分加算する	aDatetime + datetime.timedelta(days=n)
文字列の色で数列とリストの折れ線グラフを描く	plt.plot(xdata, ydata, color=s)
日付時刻データにn分分加算する	aDatetime + datetime.timedelta(minutes=n)
折れ線グラフを描画して、その色をモカシンに設定する	plt.plot(データ列, データ列2, color='moccasin')
＜オプション＞耐火レンガ色を使う	color = 'firebrick'
ポイントマーカーとして散布図をプロットする	plt.plot(xdata, ydata, marker='.')
表データからカテゴリデータのカラム名の一覧を見る	df.select_dtypes('object').columns
色差別ない色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='colorblind')
＜オプション＞オレンジ色を使う	color = 'orange'
＜オプション＞線幅をnに設定する	linewidth = n
＜オプション＞ダークグレー色を使用する	color = 'darkgray'
双方向キューの右の要素	deq[-1]
リストと配列の散布図に黒いポイントマーカーをプロットする	plt.plot(xdata, ydata, marker='.', c='k')
イテラブルとリストについての散布図に黒色の星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='k')
Pandasで、データ列を日付データに変換し、データフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(ds))
ヒストグラムの色をダーク・スラテグレーに設定する	plt.hist(データ列, color='darkslategrey')
データフレームのカラムの中に文字列が存在するかどうか調べる	df[col].isin([value])
ヒストグラムの色をオールドレースに設定する	plt.hist(データ列, color='oldlace')
データフレームが正規分布からどの程度、尖っているか確認する	df.skew()
リストをイミュータブルにする	tuple(aList)
ヒストグラムの色をデピンクに設定する	plt.hist(データ列, color='deeppink')
ヒストグラムを描画して、その色をオリベドラブに指定する	plt.hist(データ列, color='olivedrab')
暗い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
Pandasで、データフレームのcollを日付データに変換する	pd.to_datetime(df[col])
JSONファイルの入力を辞書にする	json.load(fin)
ベクトルの行ごとの最小値を求める	np.min(aArray, axis=1)
エクセルデータファイルからnという名前のシートを読み込む	pd.read_excel(filename, sheet_name=n)
＜オプション＞ライトグレーにグラフの色を指定する	color = 'lightgrey'
データフレームを各列毎にグループ化して、文字列というグループを使う	df.groupby(column).get_group(s)
リストとリストについてカラーコードの濃いを描画する	plt.plot(xdata, ydata, linestyle='deep', color=rgb)
文字列が文字列リストに含まれるかどうか確認する	s in aStringList
配列の列ごとの平均値	np.mean(aArray, axis=0)
ロージーブラウンにヒストグラムの色をセットする	plt.hist(データ列, color='rosybrown')
ヒストグラムを描画して、色をシアンに設定する	plt.hist(データ列, color='cyan')
再帰の最大回数を上げる	sys.setrecursionlimit(1000000)
グラフの色をパステル調にする	sns.set(pallete='pastel')
日付時刻データが日付時刻データより前	aDatetime < aDatetime2
実数を小数点以下で丸める	round(x, n)
データフレームのリスト列の相関行列スピアマン相関係数で	df[aList].corr(method='spearman')
文字列の開始位置以降が部分文字列で始まるか調べる	s.startswith(sub, start)
折れ線グラフを描画して、その色をイエローグリーンに設定する	plt.plot(データ列, データ列2, color='yellowgreen')
リストとリストについての散布図にダイアモンドマーカーを描画する	plt.plot(xdata, ydata, marker='D')
データフレームの列のユニークな要素数	df[col].nunique()
配列のユニークな値を要素とする配列	np.unique(aArray)
Pandasで、フォーマットfmtでデータフレームのcollを日付データに変換する	pd.to_datetime(df[col], format=fmt)
配列の次元数を求める	aArray.ndim
両端キューの最後から要素を取り出す	deq.pop()
行列のムーア・ペンローズの擬似逆行列	np.linalg.pinv(aArray)
折れ線グラフの△マーカーを黄色くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='y')
線グラフを描画してその色をライトイエローに変更する	plt.plot(データ列, データ列2, color='lightyellow')
文字列中にひとつでも非英数字が含まれるか	any(not c.isalnum() for c in s)
等間隔でn個にデータ列を分割する	pd.cut(ds, n)
折れ線グラフに丸マーカーを使う	plt.plot(データ列, データ列2, marker='o')
データフレームの列とカラムの相関行列をヒートマップで描画する	sns.heatmap(df[[column, column2]].corr())
ゲインズボロ色の線グラフを描画する	plt.plot(データ列, データ列2, color='gainsboro')
実数がNaNか判定する	math.isnan(x)
パステル調の色の折れ線を描画し、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
ブラック色のヒストグラムを描画する	plt.hist(データ列, color='black')
インデント幅nで辞書をJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, indent=n)
データ列を等量でビン数nでビン分割する	pd.qcut(ds, n)
＜オプション＞エンコーディングを文字コードtextに指定する	encoding = text
リストをビン数nを用いてビン分割する	pd.cut(aList, n)
リストとタプルをペアのリストに変換する	itertools.zip_longest(iterable, iterable2)
ヒストグラムを描画してその色をゴーストホワイトに変更する	plt.hist(データ列, color='ghostwhite')
点線で折れ線グラフを描画する	plt.plot(データ列, データ列2, linestyle='dotted')
折れ線グラフを描画して、その色をピーチパフに設定する	plt.plot(データ列, データ列2, color='peachpuff')
文字列の開始位置以降に部分文字列が含まれるか調べる	s.find(sub, start) != -1
標準入力から1行だけ改行なしで読む	sys.stdin.readline().rstrip()
日付時刻データの日数	aDatetime.day
データフレームのカラムの欠損値を前の行の値にセットする	df[col].fillna(method='ffill')
リスト中の最初の文字列を探す	aList.index(element)
カラーコードの左三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='<', c=rgb)
タプルの最初を捨てる	aTuple[1:]
データ列とリストの破線グラフを描いて、その色を暗いに設定する	plt.plot(xdata, ydata, linestyle='dash', color='dark')
折れ線グラフを描画して、その色をダークカーキに設定する	plt.plot(データ列, データ列2, color='darkkhaki')
柱状図をstartからendまでの範囲で描く	plt.hist(データ列, range=(start, end))
文字列の開始位置番目と終了位置番目の間に部分文字列が含まれないか調べる	s.find(sub, start, end) == -1
データフレームをタブ区切りでJSONLファイルに保存する	df.to_csv(filename, sep='\t')
暗いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='dark', color=rgb)
アイボリー色の線グラフを描画する	plt.plot(データ列, データ列2, color='ivory')
配列とリストについての散布図に赤色の星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='r')
＜オプション＞セパレータを文字列にする	sep = s
＜オプション＞コロンを分割記号で用いる	sep = ':'
折れ線グラフを描画して、その色をやわらかい青に設定する	plt.plot(データ列, データ列2, color='cornflowerblue')
データフレームの列の一覧	df.info()
データフレームの行がnの行を抽出する	df.loc[n]
ヒストグラムの色をコーンズシルクに設定する	plt.hist(データ列, color='cornsilk')
ケンドール順位相関係数で表データのリスト列の相関行列を計算する	df[aList].corr(method='kendall')
双方向キューから最初の要素を取り除く	deq.remove(element)
＜オプション＞色をスプリンググリーンに設定する	color = 'springgreen'
配列のユニークな要素	np.unique(aArray)
データフレームの列の欠損値をメディアンに設定する	df[col].fillna(df[col].median())
色差別ない色でヒストグラムを描画する	plt.hist(xdata, color='colorblind')
折れ線グラフを描画して、その色をダークオレンジに設定する	plt.plot(データ列, データ列2, color='darkorange')
データフレームを二つの列の値によってグループ化し要約統計量を算出する	df.groupby(['A', 'B']).describe()
集合が空か調べる	len(aSet) == 0
要素が両端キューの中にあるかどうか確認する	element in deq
＜オプション＞グラフの色をライトシアンに設定する	color = 'lightcyan'
xの小数点以下'4'桁までの文字列に変換する	':.4f'.format(x)
カウンタの下位を列挙する	aCounter.most_common()[:-n-1:-1]
実数を実数で割った剰余	math.remainder(x, x2)
辞書をチェーンマップにする	collections.ChainMap(aDict)
データフレームの列が文字列で終わらないデータを抽出する	df[not df[column].str.endswith(s)]
ヒストグラムを描画して、その色をゴーストホワイトに設定する	plt.hist(データ列, color='ghostwhite')
実数を実数で割って、切り捨てる	x // y
データフレームを'A'列によって昇順にソートする	df.sort_values(by='A', ascending=True)
棒グラフを描いて中央寄せする	plt.bar(ラベル列, データ列, align='center')
ライトゴールドロディイエロー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightgoldenrodyellow')
Pandasで、エポック秒の文字列からタイムスタンプ型に変換する	pd.to_datetime(s, unit='s', utc=True)
ヒストグラムの色をミッドナイトブルーに指定する	plt.hist(データ列, color='midnightblue')
整数nを二進表現に変換する	bin(n)
ふたつの集合が集合と互いに素か調べる	aSet.isdisjoint(aSet2)
文字列をASCII限定としてパターンで区切る	re.split(pattern, s, flags=re.ASCI)
黒い左三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='<', c='k')
データフレームの列が文字列で終わる行を選択する	df[df[column].str.endswith(s)]
リストをビン数nで等量でビン分割する	pd.qcut(aList, n)
＜オプション＞ネイビー色を使う	color = 'navy'
十六進数字を全て求める	string.hexdigits
非数	math.nan
折れ線グラフを一点鎖線で描画する	plt.plot(データ列, データ列2, linestyle='dashbot')
散布図に黒いバツマーカーを使う	plt.plot(xdata, ydata, marker='x', c='k')
＜オプション＞ダークオレンジに色を設定する	color = 'darkorange'
＜オプション＞パールバイオレットレッドにグラフの色を変更する	color = 'palevioletred'
＜オプション＞トマトに色を設定する	color = 'tomato'
実行結果を紫色でプリントできる文字列にする	f'\033[35m{value}\033[0m'
x,yの複素数	complex(x, y)
浮動小数点数の自然対数	math.log(x)
ヒストグラムを描画して、色をシャルトリューズに設定する	plt.hist(データ列, color='chartreuse')
折れ線グラフのクロス印を青くする	plt.plot(データ列, データ列2, marker='x', markerfacecolor='b')
リストとリストについての散布図に赤色の大バツマーカーを描く	plt.plot(xdata, ydata, marker='X', c='r')
表データをグループ化し、各列に対し個数を計算する	df.groupby(column)[column2].count()
折れ線グラフを描画してその色をコーラルに設定する	plt.plot(データ列, データ列2, color='coral')
折れ線グラフの丸マーカーの大きさをnに指定する	plt.plot(データ列, データ列2, marker='o', markersize=n)
＜オプション＞グラフの色をスチールブルーに設定する	color = 'steelblue'
リストと数列について散布図を描画して、マーカーを四角に設定する	plt.plot(xdata, ydata, marker='s')
今日が水曜日か調べる	datetime.datetime.today().weekday() == 2
グリーン色のヒストグラムを描画する	plt.hist(データ列, color='green')
文字列の最後から部分文字列を探す	s.rfind(sub)
配列の変化を折れ線にプロットする	plt.plot(range(len(xdata)), xdata)
グラフを全般的にパステル調にする	sns.set(pallete='pastel')
データフレームの列の文字列が文字列で始まるデータを取り出す	df[df[column].str.startswith(s)]
データ列が何曜日か見る	ds.dt.weekday_name
リストと配列について青い暗いグラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='b')
降順にデータフレームを複数の列によって破壊的にソートする	df.sort_values(by=column, ascending=False, inplace=True)
ゴールデンロッド色のヒストグラムを描画する	plt.hist(データ列, color='goldenrod')
濃い色のマーカーで散布図を描画する	plt.plot(xdata, ydata, c='deep')
シアンで実行結果を表示する	print(f'\033[36m{value}\033[0m')
ヒストグラムを描画して、その色をスラグレーに指定する	plt.hist(データ列, color='slategray')
＜オプション＞濃い青色を用いる	color = 'darkblue'
辞書のキー一覧を得る	list(aDict)
データフレームの数値をまとめて整数に丸める	df.round()
ヒストグラムを描画してその色をペルーにする	plt.hist(データ列, color='peru')
ヒストグラムの色をリネンに指定する	plt.hist(データ列, color='linen')
赤色の左三角マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='<', c='r')
Pandasでフォーマットfmtでデータフレームのcollを日付データに変換する	pd.to_datetime(df[col], format=fmt)
データ列の年	ds.dt.year
文字列を区切りで分割して、文字列リストにする	s.split(sep)
辞書の項目名を要素に設定する	aDict[key] = element
整数nをバイト列に変換する	n.to_bytes(length=bytesize, byteorder='big')
赤い明るいの折れ線を描く	plt.plot(xdata, ydata, linestyle='bright', color='r')
二つのデータ列を並べてヒストグラムにする	plt.hist([データ列, データ列2], color=['b', 'r'])
最小値でデータフレームの列の欠損値を埋める	df[col].fillna(df[col].min())
オレンジ色のヒストグラムを描画する	plt.hist(データ列, color='orange')
文字列の左側からタブを取り除く	s.lstrip('\t')
折れ線グラフの色をパレットトルコイズに変更する	plt.plot(データ列, データ列2, color='paleturquoise')
データフレームから指定された名前リストの列を選択する	df[columns]
データフレームを列の値ごとに分類して、列挙する	[(name, group) for name, group in df.groupby(column)]
データ列をインポートする	import pandas as pd
表示可能な行数を減らす	pd.set_option('display.max_rows', n)
＜オプション＞ダークマゼンタ色を使う	color = 'darkmagenta'
プロットで使うx軸にuntitledというラベルを付ける	plt.xlabel(untitled)
n2がn以上、かつ、n3以下か調べる	n <= n2 and n2 <= n3
線グラフを描画して、その色を黄緑にセットする	plt.plot(データ列, データ列2, color='chartreuse')
データフレームを各列と列の組み合わせ毎にグループ化し、、分散を計算する	df.groupby([column, column2], as_index=False).var()
散布図にカラーコードの下三角マーカーを使う	plt.plot(xdata, ydata, marker='v', c=rgb)
文字列の示すエンコーディングでファイルパスをオープンする]	open(filepath, encoding=s)
改行で区切って二つの変数をプリントする	print(value, value2, sep='\n')
データフレームのカラムの欠損値を直後の値にセットする	df[col].fillna(method='bfill')
キーが辞書上で未定義か調べる	key not in aDict
数値を赤色でプリントできる文字列にする	f'\033[31m{value}\033[0m'
＜オプション＞ブルーバイオレットを使う	color = 'blueviolet'
＜オプション＞デピンクを用いる	color = 'deeppink'
折れ線グラフの色をオリーブに変更する	plt.plot(データ列, データ列2, color='olive')
数列と数列について暗い色の折れ線グラフを描画し、、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='dark')
データフレームの列が正規分布からどの程度、歪んでいるか見る	df[col].kurt()
データ列の中にいくつ欠損値があるか数える	ds.isna().sum()
＜オプション＞バイナリ書き込みモードを使う	mode = 'wb'
折れ線グラフを描画して、その色をプラムに設定する	plt.plot(データ列, データ列2, color='plum')
JSONLファイルにデータフレームをTSVを用いて保存する	df.to_csv(filename, sep='\t')
実数の床を求める	math.floor(x)
データフレームの行を範囲指定して選択する	df[start:end]
＜オプション＞ビスク色を使う	color = 'bisque'
イテラブルとリストの散布図に黒色の星マーカーを描画する	plt.plot(xdata, ydata, marker='*', c='k')
実数を小数点で丸める	round(x, n)
データフレームの欠損値を平均値で埋める	df.fillna(df.mean())
データフレームを'A'列によってソートして、NaNを先頭にする	df.sort_values(by='A', na_position='first')
リストについてのヒストグラムを淡いで描く	plt.hist(xdata, color='muted')
データ列を折れ線グラフに描画して、印を星印にする	plt.plot(データ列, データ列2, marker='*')
n×n2	n * n2
ヒストグラムの色をダークマゼンタに設定する	plt.hist(データ列, color='darkmagenta')
データフレームを列によってグループ化して、それぞれのグループごとの合計を求める	df.groupby(column).sum()
＜オプション＞色を紺に設定する	color = 'darkblue'
折れ線グラフのマーカーをポイントにする	plt.plot(データ列, データ列2, marker='.')
カウンタ同士で∪を求める	aCounter | aCounter2
ヒストグラムを描画して、その色をアクアに設定する	plt.hist(データ列, color='aqua')
データフレームの平均値	df.mean()
二つの表データをジョインする	pd.merge(df, df2)
＜オプション＞バイナリモードに変更する	mode = 'rb'
ヒストグラムの色をロージーブラウンに設定する	plt.hist(データ列, color='rosybrown')
ヒストグラムを描画して、色をダークオレンジにセットする	plt.hist(データ列, color='darkorange')
列'A'と列'B'をキーとして2つのデータフレームを右結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
Pythonインタプリタの実行ファイルの絶対パス	sys.executable
両端キューの大きさ	len(deq)
文字列中にひとつでも非大文字が含まれるか調べる	any(not c.isupper() for c in s)
データ列とラベル列を指定して、積み上げ棒を描画する	"plt.bar(ラベル列, データ列, bottom=データ列2, color=""red"")"
折れ線グラフの色をカーキに設定する	plt.plot(データ列, データ列2, color='khaki')
日付データをタプルに変換する	aDate.timetuple()
二つのデータフレームを縦方向に合体させる	pd.concat([df, df2])
折れ線グラフのクロスマーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='x', markersize=n)
本日をISO形式の文字列に変換する	datetime.datetime.today().isoformat()
データフレームの列の値がxより大きくx2より小さい行を選択する	df[(x < df[column]) & (df[column] < x2)]
データフレームのリスト列の中にある文字列の合計を数える	df[aList].isin([value]).sum()
最初のカテゴリーを除外してデータフレームの列をダミー変数に変換する	pd.get_dummies(df[column], drop_first=True)
データフレームの行を条件で消すには	df[(df[column] == x) & (df[column2] == x2)]
数列とリストの散布図を重なりを見やすく明るい色で描画する	plt.plot(xdata, ydata, c='bright', alpha=0.5)
オプションで、ファイルに出力する	file = sys.open(filename, 'w')
折れ線グラフに黒い右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='k')
数列とデータ列の青い濃いを描画する	plt.plot(xdata, ydata, linestyle='deep', color='b')
文字列を下線付きで表示できる文字列に変換する	f'\033[4m{value}\033[0m'
リストと数列について濃いグラフを描画して、色を黒にする	plt.plot(xdata, ydata, linestyle='deep', color='k')
折れ線グラフの色を茶色に変更する	plt.plot(データ列, データ列2, color='brown')
＜オプション＞グラフの色を小麦色に設定する	color = 'wheat'
クラスのサブクラスか調べる	issubclass(サブクラス, クラス)
ヒストグラムを描画して、その色をライトゴールドロディイエローにする	plt.hist(データ列, color='lightgoldenrodyellow')
nとn2の差	n - n2
文字列がリストの要素	element in aList
＜オプション＞グラフの色をピンクに設定する	color = 'pink'
イテラブルを文字列リストに変換して、カンマでつなげる	','.join(map(str, iterable))
折れ線グラフの色をミディアムスプリンググリーンに設定する	plt.plot(データ列, データ列2, color='mediumspringgreen')
配列の列ごとの合計値を求める	np.sum(aArray, axis=0)
データフレームの列をワンホット・ベクトルにする	pd.get_dummies(df[column])
データフレームを二つの列の値で集約する	df.groupby(['A', 'B'])
データフレームの最頻値	df.mode()
＜オプション＞データ型を指定する	dtype = np.int
リストと数列の散布図を描画し、その大きさをnに設定する	plt.scatter(xdata, ydata, s=n)
データ列をインポートする	import pandas as pd
リストとリストについての散布図に黒い下三角マーカーを描画する	plt.plot(xdata, ydata, marker='v', c='k')
データフレームを二つの列によってソートする	df.sort_values(by=['A', 'B'])
ヒストグラムの色をラベンダーに設定する	plt.hist(データ列, color='lavender')
破線に折れ線グラフのスタイルを設定する	plt.plot(データ列, データ列2, linestyle='dashed')
データフレームの中の列と列に重複があれば、削除する	df.drop_duplicates(subset=column)
＜オプション＞８ビット整数型を使用する	dtype = np.int8
＜オプション＞左三角マーカーを使う	marker = '<'
ヒストグラムの色をフクシアに設定する	plt.hist(データ列, color='fuchsia')
赤色の左三角マーカーを散布図に用いる	plt.plot(xdata, ydata, marker='<', c='r')
オブジェクトがリストに含まれる	element in aList
折れ線グラフの色をライムグリーンに設定する	plt.plot(データ列, データ列2, color='limegreen')
青い暗いグラフをプロットする	plt.plot(xdata, ydata, linestyle='dark', color='b')
折れ線グラフの色を黄緑に変更する	plt.plot(データ列, データ列2, color='chartreuse')
カラーコードの右三角マーカーをリストとデータ列についての散布図に描画する	plt.plot(xdata, ydata, marker='>', c=rgb)
ディムグレーにヒストグラムの色を変更する	plt.hist(データ列, color='dimgrey')
文字列の先頭から空白を消す	s.lstrip()
ゼロ埋めした符号なし８ビット整数型の行列	np.zeros(要素数, dtype=np.uint8)
折れ線グラフに黒いダイアモンドマーカーを描画する	plt.plot(データ列, データ列2, marker='D', markerfacecolor='k')
リストと配列の折れ線グラフを描き、、透明度をalphaに設定する	plt.plot(xdata, ydata, alpha=alpha)
データ列の最頻値	ds.mode()
データフレームの列の名前一覧で指定した列を削除する	df.drop(columns, axis=1)
データフレームの列の名前一覧を使う	df.columns
＜オプション＞グラフの色をレモンシフォンにセットする	color = 'lemonchiffon'
パステル調のグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='pastel', color='k')
文字列を隔離する	sys.intern(s)
実数を三乗する	x ** 3
ダークグリーンにヒストグラムの色を変更する	plt.hist(データ列, color='darkgreen')
表示可能な列数を減らす	pd.set_option('display.max_columns', n)
エンコーディングを使う	sys.getdefaultencoding()
＜オプション＞ピンク色を使う	color = 'pink'
ふたつの集合の共通要素だけに更新する	aSet.intersection_update(aSet2)
文字列をセパレータで区切って、列挙する	s.split(sep)
ふたつの集合が互いに素か	aSet.isdisjoint(aSet2)
nがn2未満、またはn3以上か調べる	n < n2 or n >= n3
折れ線グラフのマーカーを左三角にする	plt.plot(データ列, データ列2, marker='<')
色差別ないグラフの色を黒色に変更する	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
データフレームの列がxより多くx2より少ないデータを抽出する	df[(x < df[column]) & (df[column] < x2)]
データフレームとデータ列を横方向に連結する	pd.concat([df, ds], axis=1)
折れ線グラフのポイントマーカーを黒色にする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='k')
淡い色で散布図を描画する	plt.plot(xdata, ydata, c='muted')
オプションで、標準出力を出力にする	file = sys.stdout
データフレームを'A'列によって昇順に破壊的にソートする	df.sort_values(by='A', ascending=True, inplace=True)
日付と時刻から日付時刻	datetime.datetime(年, 月, 日, 時, 分, 秒)
折れ線グラフを用いてデータフレームのカラムとカラムを描画する	plt.plot(df[col], df[col2])
シスルにヒストグラムの色を指定する	plt.hist(データ列, color='thistle')
リストとリストの散布図をプロットして、△マーカーの色をカラーコードに変更する	plt.plot(xdata, ydata, marker='^', c=rgb)
データ列の中に文字列と文字列がいくつあるか数える	ds.isin([value, value2]).sum()
データフレームを表示するとき、n列までデータフレームを表示可能なようにする	pd.set_option('display.max_columns', n)
ヒストグラムの色をパレットトルコイズに設定する	plt.hist(データ列, color='paleturquoise')
nがn2かどうか調べる	n == n2
折れ線グラフの色をローングリーンに変更する	plt.plot(データ列, データ列2, color='lawngreen')
二次元リストの転置行列	[list(x) for x in list(zip(*aList))]
ヒストグラムの色をダークグレーに変更する	plt.hist(データ列, color='darkgray')
ヒストグラムを描画して、色をグレーに設定する	plt.hist(データ列, color='grey')
＜オプション＞ペルーに色を指定する	color = 'peru'
リストとリストについて散布図をプロットして、マーカーを大バツに設定する	plt.plot(xdata, ydata, marker='X')
オブジェクトが浮動小数点数クラス	isinstance(obj, float)
ベクトルの最小	np.min(aArray)
データフレームのリストカラムの中にある文字列と日付データの数をカウントする	df[aList].isin([value, value2]).sum()
整数nをバイト列に変換する	n.to_bytes((n.bit_length() + 7) // 8, byteorder='big')
グラフに水平方向の破線をつける	plt.axhline(y=0, linestyle='dashed')
コーラル色のヒストグラムを描画する	plt.hist(データ列, color='coral')
折れ線グラフに黄色い四角マーカーを描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='y')
＜オプション＞ライトスレイグレー色を使う	color = 'lightslategrey'
イテラブルとリストについての散布図に黒い大バツマーカーを描く	plt.plot(xdata, ydata, marker='X', c='k')
双方向キューを作る	collections.deque()
文字列を最後の部分文字列で二分し、後半の文字列を使う	s.rpartition(sub)[-1]
折れ線グラフの色をドジャーブルーに設定する	plt.plot(データ列, データ列2, color='dodgerblue')
空白文字を全部使う	string.whitespace
データフレームを転置する	df.T
データフレームから列を４つ選択する	df[[column, column2, column3, column4]]
要素が全て1の配列	np.ones(要素数, dtype=np.int)
ヒストグラムを描画して、その色をブルーバイオレットに設定する	plt.hist(データ列, color='blueviolet')
タプルを引数として展開して表示する	print(*aTuple)
線グラフを描画してその色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategray')
辞書を並べ直してJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, sort_keys=True)
nが1、もしくは2かどうか	n == 1 or n == 2
データフレームをJSONLファイルにBOMを付けて保存する	df.to_csv(filename, encoding='utf_8_sig')
データフレームを各列と列の組み合わせ毎にグループ化して、標準偏差を求める	df.groupby([column, column2], as_index=False).std()
エクセルデータファイルをデータフレームとして読み込む	pd.read_excel(filename)
集合のイミュータブル版	frozenset(aSet)
＜オプション＞色をカデットブルーに設定する	color = 'cadetblue'
ミディアムスレートブルー色のヒストグラムを描画する	plt.hist(データ列, color='mediumslateblue')
オブジェクトが浮動小数点数型	isinstance(obj, float)
nが一桁の数か	-9 <= n <= 9
両端キューの長さを制限する	collections.deque(maxlen=n)
リストと配列についての散布図にデータラベル用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
数に数を加える	x + y
データフレームのカラムが何日か見る	df[col].dt.day
リストとデータ列について散布図をプロットして、下三角マーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='v', c=rgb)
異なる列をキーとして二つのデータフレームを右結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
改行なしに変数をプリントする	print(value, end='')
＜オプション＞グラフの色をレベッカパープルに設定する	color = 'rebeccapurple'
＜オプション＞グラフの色をロイヤルブルーに設定する	color = 'royalblue'
データフレームの重複していない行のみを抽出する	df[not df.duplicated(keep=False)]
イテラブルと配列で色差別ないグラフを描いて、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
ヒストグラムを描画して色をパールバイオレットレッドに設定する	plt.hist(データ列, color='palevioletred')
＜オプション＞オリベドラブ色を使う	color = 'olivedrab'
配列とリストについての散布図にカラーコードの大バツマーカーを描画する	plt.plot(xdata, ydata, marker='X', c=rgb)
データ列の最頻値を求める	ds.mode()
分数を使う	import fractions
＜オプション＞グラフの色をダークシアグリーンに変更する	color = 'darkseagreen'
線グラフの色をベージュに設定する	plt.plot(データ列, データ列2, color='beige')
青い四角印を折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='s', markerfacecolor='b')
文字列の右側が部分文字列か調べる	s.endswith(sub)
リストの要素を小さい順にソートする	sorted(aList, reverse=True)
文字列はリストに含まれないか	element not in aList
マッピングをJSONフォーマットの文字列に変換する	json.dumps(aDict, ensure_ascii=False)
＜オプション＞３二ビット整数型を使用する	dtype = np.int16
ヒストグラムの色をライトブルーに変更する	plt.hist(データ列, color='lightblue')
折れ線グラフに黄色い右三角マーカーを描画する	plt.plot(データ列, データ列2, marker='>', markerfacecolor='y')
正規表現に文字列がマッチさせる	re.match(pattern, s)
二つのデータフレームを列をキーにして全結合する	pd.merge(df, df2, on=column, how='outer')
＜オプション＞色をシエナに設定する	color = 'sienna'
折れ線グラフに大バツマーカーを使う	plt.plot(データ列, データ列2, marker='X')
リストとリストについての散布図に赤い右三角マーカーを描画する	plt.plot(xdata, ydata, marker='>', c='r')
二つの集合が共通の要素を持たないか	aSet.isdisjoint(aSet2)
本日が何年か知る	datetime.datetime.today().year
折れ線グラフに三角マーカーを使う	plt.plot(データ列, データ列2, marker='^')
＜オプション＞パウダーブルーにグラフの色を設定する	color = 'powderblue'
データフレームの列がx以上の行を取り出す	df[df[column] >= x]
青いクロスマーカーを折れ線グラフに描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='b')
データフレームの欠損値を直前の値で埋める	df.fillna(method='ffill')
データフレームの中のカラムをビン数nとしてビン分割し、namesのラベルをつける	pd.cut(df[col], n, labels=names)
等差数列から整数乱数を求める	random.randrange(start, end, step)
カラーコードに棒の色を設定する	plt.bar(ラベル列, データ列, color=rgb)
データフレームのリストカラムの中にいくつが存在するかカウントする	df[aList].isin([value]).sum()
文字列全体が正規表現にASCII限定としてマッチするか見る	re.fullmatch(pattern, s, flags=re.ASCI)
散布図に赤い星マーカーを使用する	plt.plot(xdata, ydata, marker='*', c='r')
ヒストグラムの色をミントクリームにセットする	plt.hist(データ列, color='mintcream')
データ列をビン数nで分割し、、namesのラベルをつける	pd.cut(ds, n, labels=names)
エクセルファイルファイルのn番目のシートをデータフレームとして読み込む	pd.read_excel(filename, sheet_name=n)
折れ線グラフのポイントマーカーを黒くする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='k')
ヒストグラムを描画して、その色をミッドナイトブルーに変更する	plt.hist(データ列, color='midnightblue')
nをn2で割った値の切り上げ	(n + n2 - 1) // n2
ヒストグラムの色をオリベドラブに指定する	plt.hist(データ列, color='olivedrab')
＜オプション＞グラフの色をチョコレートに指定する	color = 'chocolate'
＜オプション＞やわらかい青色を使う	color = 'cornflowerblue'
グラフの補足の位置を(x,y)にセットする	plt.legend(loc=(x, y))
データフレームの欠損値を中央値で埋める	df.fillna(df.median())
折れ線グラフの四角印の大きさをnに設定する	plt.plot(データ列, データ列2, marker='s', markersize=n)
データフレームをグループ化し、各列に対し最小値を求める	df.groupby(column)[column2].min()
＜オプション＞ミディアムパープルにグラフの色を変更する	color = 'mediumpurple'
リストとリストについて散布図を描画して、マーカーを四角に設定する	plt.plot(xdata, ydata, marker='s')
線グラフを描画して、その色をグレーに設定する	plt.plot(データ列, データ列2, color='gray')
要素ひとつのりスト	[element]
明るい色のマーカーで散布図を描く	plt.plot(xdata, ydata, c='bright')
ヒストグラムの色をアクアに設定する	plt.hist(データ列, color='aqua')
折れ線グラフの色を黒くする	plt.plot(データ列, データ列2, color='k')
データフレームを列名リストの値で集計する	df.groupby(columns)
カラーパレットを濃くする	sns.set(pallete='deep')
パレットトルコイズにヒストグラムの色を変更する	plt.hist(データ列, color='paleturquoise')
データフレームを'A'列ごとに集計して、列挙する	[(name, group) for name, group in df.groupby('A')]
本日が火曜日か調べる	datetime.datetime.today().weekday() == 1
淡い色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='muted')
折れ線グラフを描画してその色をフローラルホワイトに設定する	plt.plot(データ列, データ列2, color='floralwhite')
明るいグラフの色を黒くする	plt.plot(xdata, ydata, linestyle='bright', color='k')
xを浮動小数点数に変換する	float(x)
リストとデータ列についての散布図をパステル調の色で描画する	plt.plot(xdata, ydata, c='pastel')
文字列が文字列リストにあるか調べる	s in aStringList
リストのn番目からn2番目を取り出す	aList[n:n2]
ファイルを開いて]、バイナリ書き込みストリームを使う	open(filepath, mode='wb')
文字列リストをsepを区切りにしてひとつの文字列にする	sep.join(aStringList)
数字を全て使う	string.digits
配列の平均を求める	np.mean(aArray)
マッピングをソートしてJSON形式の文字列に変換する	json.dumps(aDict, ensure_ascii=False, sort_keys=True)
折れ線グラフの右三角印の線幅をnに設定する	plt.plot(データ列, データ列2, marker='>', markeredgewidth=n)
折れ線グラフの三角印を赤くする	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
リストとリストの折れ線グラフをカラーコードで描画する	plt.plot(xdata, ydata, color=rgb)
＜オプション＞グラフの色をグレーに設定する	color = 'gray'
xの小数点以下'4'桁までをプリントする	print(':.4f'.format(x))
データフレームを10の位で丸めて、整数型にする	df.round(-1).astype(int)
二つの文字列をタブで区切ってプリントする	print(value, value2, sep='\t')
ヒストグラムを描画して、色をライトスチールブルーに設定する	plt.hist(データ列, color='lightsteelblue')
＜オプション＞マルーン色を用いる	color = 'maroon'
最大長nの両端キューを用意する	collections.deque(maxlen=n)
線グラフの色をライトシアンに設定する	plt.plot(データ列, データ列2, color='lightcyan')
折れ線グラフを描画して、その色をダークターコイズに設定する	plt.plot(データ列, データ列2, color='darkturquoise')
ヒストグラムの色を暗い赤に設定する	plt.hist(データ列, color='darkred')
日付データからn週間を減算する	aDate - datetime.timedelta(weeks=n)
リストとデータ列についての散布図に赤色の星マーカーをプロットする	plt.plot(xdata, ydata, marker='*', c='r')
縦棒グラフを描画して、中央寄せする	plt.bar(ラベル列, データ列, align='center')
データフレームの中の列を等量でビン数nでビン分割する	pd.qcut(df[col], n)
＜オプション＞バイナリ書き込み用に設定する	mode = 'wb'
＜オプション＞グラフの色をサーモンに指定する	color = 'salmon'
コマンドラインフラグの状態	sys.flags
文字列は全て識別子名かどうか調べる	s.isidentifier()
変数について数式の積分を行う	sympy.integrate(e, z)
折れ線グラフの色をフローラルホワイトに設定する	plt.plot(データ列, データ列2, color='floralwhite')
ヒストグラムを描画して、その色をシエナに指定する	plt.hist(データ列, color='sienna')
シスル色の線グラフを描画する	plt.plot(データ列, データ列2, color='thistle')
データフレームのリストカラムは正規分布からどの程度、尖っているか調べる	df[aList].skew()
オブジェクトのフィールドの値を値に設定する	setattr(obj, プロパティ名, 値)
文字列が全て空白からなるかどうか	s.isspace()
＜オプション＞グラフの色をナバホホワイトにする	color = 'navajowhite'
＜オプション＞エラーがあるとき、例外を発生させるように設定する	errors = 'strict'
ケンドール順位相関係数でデータフレームのリストで指定されたカラムの相関行列を求める	df[aList].corr(method='kendall')
データ列の中にいくつ欠損値が含まれるかカウントする	ds.isna().sum()
リストとリストについて相関を可視化する	plt.scatter(xdata, ydata)
パステル調の色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
エラーを無視して文字列をバイト列に変換する	s.encode(errors='ignore')
線グラフの色をミディアムバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='mediumvioletred')
線グラフを描画してその色をダークマゼンタに設定する	plt.plot(データ列, データ列2, color='darkmagenta')
＜オプション＞ブラックを使う	color = 'black'
ヒストグラムの色をドジャーブルーに設定する	plt.hist(データ列, color='dodgerblue')
散布図にパステル調の色のマーカーを使う	plt.plot(xdata, ydata, c='pastel')
ダークレッド色の線グラフを描画する	plt.plot(データ列, データ列2, color='darkred')
日付時刻データを浮動小数点数に変換する	aDatetime.timestamp()
フローラルホワイトにヒストグラムの色を指定する	plt.hist(データ列, color='floralwhite')
部分文字列を文字列の先頭から見つける	s.find(sub)
ヒストグラムの色をライトサーモンに変更する	plt.hist(データ列, color='lightsalmon')
ヒストグラムを描画して、その色をサーモンに設定する	plt.hist(データ列, color='salmon')
n個の文字列があるリスト	[element] * n
データ列を小数点以下n桁で四捨五入する	ds.round(n)
暗い色を用いて重なりを見やすくイテラブルと配列についての散布図を描画する	plt.plot(xdata, ydata, c='dark', alpha=0.5)
イテラブルを文字列リストに変換して、部分文字列で結合する	sub.join(map(str, iterable))
数列を暗い色のヒストグラムで描画する	plt.hist(xdata, color='dark')
データフレームの列のヒストグラムを描く	plt.hist(df[column])
実数の双曲線正弦を求める	math.sinh(x)
nからstep間隔で無限にカウントアップする	itertools.count(start=n, step=step)
＜オプション＞読み込みモードに設定する	mode = 'r'
データフレームのリストカラムの中に含まれる日付データと文字列の合計を求める	df[aList].isin([value, value2]).sum()
＜オプション＞の線幅をnに設定する	linewidth = n
リストの度数分布図を描画する	plt.hist(aList)
リストとリストでパステル調のグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='pastel', color='r')
数列とイテラブルについてパステル調の色の折れ線を描画してその線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
文字列を部分文字列で二つに区切って、前半の文字列を使う	s.partition(sub)[0]
浮動小数点数のn乗して実数による余り	pow(x, n, y)
グラフのカラーパレットをパステル調にする	sns.set(pallete='pastel')
ヒストグラムを描画して、色をリネンに設定する	plt.hist(データ列, color='linen')
データフレームを'A'列でグループ化する	df.groupby('A')
＜オプション＞オリーブ色を用いる	color = 'olive'
ヒストグラムを描画して、その色を青に設定する	plt.hist(データ列, color='blue')
線グラフの色をライトグレーに変更する	plt.plot(データ列, データ列2, color='lightgray')
＜オプション＞読み込み用に指定する	mode = 'r'
青色のパステル調のを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='b')
nが一桁の整数か調べる	0 <= n <= 9
データフレームを'A'列を用いてで破壊的に並べ直す	df.sort_values(by='A', inplace=True)
Pandasで、文字列をPandasの日付型に変換する	pd.to_datetime(s)
配列の差を求める	aArray - aArray2
データフレームを各列毎にグループ化して、列の個数を求める	df.groupby(column)[column2].count()
データフレームのインデックスがnの行を抽出する	df.loc[n]
配列が何のデータ型か	aArray.dtype()
＜オプション＞ダークカーキ色を使う	color = 'darkkhaki'
ヒストグラムをstartからendまでの範囲で描画する	plt.hist(データ列, range=(start, end))
リストの末尾からn番目以前の要素を得る	aList[:-n]
文字列に漢字が含まれるか調べる	re.search('[\u4E00-\u9FD0]', s)
文字列内にひとつでも大文字が含まれるか	any(c.isupper() for c in s)
カラーバーを横向きで描画する	plt.colorbar(orientation='horizontal')
ヒストグラムの色を紺碧に設定する	plt.hist(データ列, color='azure')
データフレームを複数の列で昇順にソートする	df.sort_values(by=column, ascending=True)
nとn2の論理積	n & n2
ヒストグラムの色を青に変更する	plt.hist(データ列, color='blue')
折れ線グラフを描画して、色をピンクに設定する	plt.plot(データ列, データ列2, color='pink')
リストとリストについての散布図に黒色の右三角マーカーを描く	plt.plot(xdata, ydata, marker='>', c='k')
文字列を最後の部分文字列で二分し、前半の文字列を使う	s.rpartition(sub)[0]
二つの文字列を改行で区切って表示する	print(value, value2, sep='\n')
ふたつの集合の対称差集合を求める	aSet.symmetric_difference(aSet2)
イテラブルを配列に変換する	np.array(iterable)
year年month月day日hour時を日付時刻にする	datetime.datetime(year=year, month=month, day=day, hour=hour)
タプルをコピーする	aDict.copy()
＜オプション＞パープルにグラフの色をする	color = 'purple'
淡い色の折れ線グラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='muted')
三二ビット整数型の全要素を０で初期化された行列を初期化する	np.zeros(行数, 列数, dtype=np.int16)
リストとリストについて散布図を描画して、ポイントマーカーの色をカラーコードに設定する	plt.plot(xdata, ydata, marker='.', c=rgb)
二つの実行結果を改行しないでプリントする	print(value, value2, end='')
データフレームの列が正規表現文字列にマッチしない行を取り出す	df[not df[column].str.match(s)]
空のマッピング	{}
折れ線グラフを描画してその色をデピンクに設定する	plt.plot(データ列, データ列2, color='deeppink')
文字列に漢字が含まれる	re.search('[\u4E00-\u9FD0]', s)
折れ線グラフの色をスカイブルーに設定する	plt.plot(データ列, データ列2, color='skyblue')
今日が火曜日かどうか調べる	datetime.datetime.today().weekday() == 1
最初のコマンド引数を知る	sys.argv[1]
ファイルからストリームを読み込んでfileとする	file = open(filepath)
オブジェクトにプロパティが存在するか調べる	hasattr(obj, プロパティ名)
折れ線グラフを描画して、その色をインディアンレッドに設定する	plt.plot(データ列, データ列2, color='indianred')
グラフをポスター用に設定する	sns.set(context='poster')
行列を2次元1列に変形する	aArray.reshape(-1, 1)
カラムのユニークな要素数	df[col].nunique()
グラフの見栄えを良くする	import seaborn as sns
配列とリストの散布図に四角マーカーを描画する	plt.plot(xdata, ydata, marker='s')
JSON形式のファイルを辞書に変換する	json.load(fin)
ヒストグラムを描画して、その色をイエローグリーンに設定する	plt.hist(データ列, color='yellowgreen')
オプションで、出力先を標準エラーに設定する	file = sys.stderr
事前に大文字・小文字を無視して正規表現をコンパイルする	re.compile(pattern, flag=re.IGNORECASE)
オブジェクトに属性が存在するか調べる	hasattr(obj, プロパティ名)
折れ線グラフを描画してその色をチョコレートに設定する	plt.plot(データ列, データ列2, color='chocolate')
逆順の双方向キューを使う	reversed(deq)
標準入力を得る	sys.stdin
日付時刻データからn秒分、減算する	aDatetime - datetime.timedelta(seconds=n)
データフレームのNaNを最大値で埋める	df.fillna(df.max())
リストが空か確認する	len(aList) == 0
折れ線グラフの色をサドルブラウンに設定する	plt.plot(データ列, データ列2, color='saddlebrown')
ヒストグラムを描画して、色をライトシアンに設定する	plt.hist(データ列, color='lightcyan')
大バツマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='X')
リストと数列についての散布図にカラーコードの左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c=rgb)
整数nが配列の一つか調べる	n in aArray
折れ線グラフを描画して、色をパールバイオレットレッドに設定する	plt.plot(データ列, データ列2, color='palevioletred')
リストの末尾	aList[-1]
文字列を正規表現によって置き換える	re.sub(pattern, newsub, s)
折れ線グラフの色をゲインズボロに指定する	plt.plot(データ列, データ列2, color='gainsboro')
データフレームの指定された列をリストとして選択する	df[column].values.tolist()
文字列をPandasの日付型に変換する	pd.to_datetime(s)
文字列で区切って二つの変数をプリントする	print(value, value2, sep=s)
文字列に変換して列を連結する	''.join(map(str, iterable))
ヒストグラムを描画して、色をライトイエローにする	plt.hist(データ列, color='lightyellow')
＜オプション＞グラフの色をロイヤルブルーにする	color = 'royalblue'
ヒストグラムを実線で描画する	plt.hist(データ列, linestyle='solid')
文字列が片仮名か調べる	('ァ' <= ch <= 'ン')
'A'列で昇順にデータフレームを並べる	df.sort_values(by='A', ascending=True)
実数の余弦の逆数	math.acos(x)
線グラフの色をミディアムブルーに指定する	plt.plot(データ列, データ列2, color='mediumblue')
＜オプション＞バリーウッド色を使う	color = 'burlywood'
ヒストグラムを描画して、その色をモカシンに指定する	plt.hist(データ列, color='moccasin')
＜オプション＞グラフの色をサドルブラウンに指定する	color = 'saddlebrown'
スカイブルーにヒストグラムの色を設定する	plt.hist(データ列, color='skyblue')
＜オプション＞青色を使う	color = 'blue'
ヒストグラムを描画して、その色をインディアンレッドに設定する	plt.hist(データ列, color='indianred')
＜オプション＞色をライトスチールブルーに設定する	color = 'lightsteelblue'
パステル調の色を用いてヒストグラムを描画する	plt.hist(xdata, color='pastel')
データフレームから破壊的に重複したデータを落とす	df.drop_duplicates(inplace=True)
折れ線グラフの色をダークバイオレットにする	plt.plot(データ列, データ列2, color='darkviolet')
赤い暗いの折れ線グラフを描画する	plt.plot(xdata, ydata, linestyle='dark', color='r')
文字列を文字コード列にする	[ord(ch) for ch in s]
部分文字列で文字列が終わるか判定する	s.endswith(sub)
イテラブルとイテラブルをペアのリストに変換する	itertools.zip_longest(iterable, iterable2)
オブジェクトがプロパティを持つか調べる	hasattr(obj, プロパティ名)
ヒストグラムを描画して、その色をパープルに設定する	plt.hist(データ列, color='purple')
＜オプション＞グラフの色をトマトに変更する	color = 'tomato'
＜オプション＞淡いピンク色色を使う	color = 'lightpink'
＜オプション＞インデックスを自動的な連番に設定する	index_col = None
データフレームの欠損値を最小値に設定する	df.fillna(df.min())
＜オプション＞カーキ色を使う	color = 'khaki'
ヒストグラムを描画して、その色をライトグリーンに設定する	plt.hist(データ列, color='lightseagreen')
数列とイテラブルの淡いグラフを描いて、その色を青にする	plt.plot(xdata, ydata, linestyle='muted', color='b')
青い明るいを描く	plt.plot(xdata, ydata, linestyle='bright', color='b')
リストとリストについて散布図を描画して、マーカーを丸に設定する	plt.plot(xdata, ydata, marker='o')
折れ線グラフを描画してその色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategrey')
イテラブルとデータ列について散布図を描画して、マーカーを右三角に設定する	plt.plot(xdata, ydata, marker='>')
タプルが全て真か調べる	all(aTuple)
リストとリストで淡いグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='muted', linewidth=n)
＜オプション＞ライトスカイブルー色を使用する	color = 'lightskyblue'
カウンタを辞書に変換する	dict(aCounter)
リストの全ての値をクリアにする	aList.clear()
入力ストリーム全体を行単位で分割して読み込む	f.readlines()
列と列の直積	itertools.product(iterable, iterable2)
リストを境界値としてデータ列を分割する	pd.cut(ds, aList)
折れ線グラフの色をスチールブルーに設定する	plt.plot(データ列, データ列2, color='steelblue')
折れ線グラフを描画して、その色をクリムゾンに設定する	plt.plot(データ列, データ列2, color='crimson')
二つのカウンタのいずれかに含まれる要素	aCounter | aCounter2
＜オプション＞シャルトリューズを使う	color = 'chartreuse'
文字列が文字列より辞書順で前か調べる	s < s2
n番目のシートをエクセルファイルファイルのデータフレームとして読む	pd.read_excel(filename, sheet_name=n)
タプル内の要素が少なくともひとつ真か調べる	any(aTuple)
＜オプション＞ライトスカイブルー色を使う	color = 'lightskyblue'
サブクラスか	issubclass(サブクラス, クラス)
文字列をキャピタライズする	s.capitalize()
文字列を黒色でプリントできる文字列に変換する	f'\033[30m{value}\033[0m'
データフレームのカラムの最頻値を求める	df[col].mode()
predicateFuncが真とならないイテラブルの要素	itertools.dropwhile(predicateFunc, iterable)
データフレームを列によってソートして、NaNを先頭にする	df.sort_values(by=column, na_position='first')
折れ線グラフの左三角マーカーを黒色にする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='k')
＜オプション＞クリムゾン色を使う	color = 'crimson'
リストとリストについて明るいグラフを描画して、その色を青色に設定する	plt.plot(xdata, ydata, linestyle='bright', color='b')
データフレームのカラムの欠損値を平均で置換する	df[col].fillna(df[col].mean())
辞書のキーの一覧	aDict.keys()
TSVファイルからデータフレームを読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')
リスト内の要素が全て真か調べる	all(aList)
データフレームを列によって降順に破壊的にソートする	df.sort_values(by=column, ascending=False, inplace=True)
パステル調のグラフの色を青にする	plt.plot(xdata, ydata, linestyle='pastel', color='b')
折れ線グラフを描画して、その色をペールグリーンに指定する	plt.plot(データ列, データ列2, color='palegreen')
パターンで文字列を分割する	re.split(pattern, s)
折れ線グラフの色を文字列にセットする	plt.plot(xdata, ydata, color=s)
ヒストグラムを描画して色をペルーに設定する	plt.hist(データ列, color='peru')
データフレームのカラムの記述統計量を算出する	df[col].describe()
ファイルにxを文字列に変換して書き込む	f.write(str(x))
平仮名をカタカナに変換する	''.join([chr(ord(ch) + 96) if ('ぁ' <= ch <= 'ん') else ch for ch in s])
データフレームのカラムが何曜日か見る	df[col].dt.weekday_name
グラフの描画で暗い色を使用する	sns.set(pallete='dark')
＜オプション＞グラフの色をミディアムブルーに設定する	color = 'mediumblue'
リストとリストの暗いグラフを描画して、その色を青にする	plt.plot(xdata, ydata, linestyle='dark', color='b')
ヒストグラムの色をアリスブルーに変更する	plt.hist(データ列, color='aliceblue')
カウンタのそれぞれの項目を、そのカウントだけ列挙する	aCounter.elements()
ヒストグラムの色をダークサーモンにする	plt.hist(データ列, color='darksalmon')
明るいグラフの線幅を指定する	plt.plot(xdata, ydata, linestyle='bright', linewidth=n)
オブジェクトが論理値	isinstance(obj, bool)
アルファベットの大文字を全部使う	string.ascii_uppercase
空のカウンタを作成する	collections.Counter()
文字列にイテラブルを変換して、部分文字列で連結する	sub.join(map(str, iterable))
組の中の最小値を求める	min(aTuple)
折れ線グラフの色をライトスチールブルーに設定する	plt.plot(データ列, データ列2, color='lightsteelblue')
ファイルが存在しないか調べる	not os.path.exists(filepath)
カラーコードの星マーカーで散布図を描画する	plt.plot(xdata, ydata, marker='*', c=rgb)
明るいグラフの色を青にする	plt.plot(xdata, ydata, linestyle='bright', color='b')
＜オプション＞破壊的に操作する	inplace = True
ヒストグラムを描画して、その色をチョコレートに設定する	plt.hist(データ列, color='chocolate')
＜オプション＞エンコーディングをSJISに指定する	encoding = 'shift_jis'
折れ線グラフを描画してその色をパパイヤウィップに設定する	plt.plot(データ列, データ列2, color='papayawhip')
＜オプション＞グラフの色をダークゴールデンロッドに設定する	color = 'darkgoldenrod'
配列とリストについて散布図を描画し、、文字列という凡例用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
データフレームをグループ化しそれぞれの列に対し分散を計算する	df.groupby(column)[column2].var()
暗いグラフの色を黒にする	plt.plot(xdata, ydata, linestyle='dark', color='k')
折れ線グラフに青いクロス印を描画する	plt.plot(データ列, データ列2, marker='x', markerfacecolor='b')
リストとリストで明るいグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='bright', color='r')
青にヒストグラムの色を指定する	plt.hist(データ列, color='blue')
＜オプション＞グラフの色をホットピンクに設定する	color = 'hotpink'
データフレームをグループ化し、それぞれの列に対し合計を求める	df.groupby(column)[column2].sum()
ヒストグラムの色をミディアムスプリンググリーンに設定する	plt.hist(データ列, color='mediumspringgreen')
カウンタ同士でユニオン	aCounter | aCounter2
データフレームを'A'列によってまとめたグループ	df.groupby('A')
データフレームのグループ毎の個数	df.groupby(column).count()
折れ線グラフを描画してその色をミントクリームに設定する	plt.plot(データ列, データ列2, color='mintcream')
データフレームを'A'列によって降順に破壊的にソートする	df.sort_values(by='A', ascending=False, inplace=True)
カウンタ間で和集合演算する	aCounter | aCounter2
折れ線グラフの色をビスクに設定する	plt.plot(データ列, データ列2, color='bisque')
データフレームのデータ型一覧	df.dtypes
折れ線グラフを描画して、その色をダークレッドに設定する	plt.plot(データ列, データ列2, color='darkred')
文字列を全て大文字にする	s.upper()
データ列の日	ds.dt.day
今日の日付時刻	datetime.datetime.now()
両端キューの中に要素が含まれてるか調べる	element in deq
ヒストグラムを描画してその色を淡い茶色に設定する	plt.hist(データ列, color='tan')
データフレームの中の欠損値がある行をドロップする	df.dropna()
リストと配列の黒い色差別ないを描く	plt.plot(xdata, ydata, linestyle='colorblind', color='k')
空のカウンタ	collections.Counter()
リストとリストについての散布図をパステル調の色で重なりを見やすく描画する	plt.plot(xdata, ydata, c='pastel', alpha=0.5)
ヒストグラムを描画して、その色をライトスレイグレーに設定する	plt.hist(データ列, color='lightslategray')
ミディアムオーキッド色のヒストグラムを描画する	plt.hist(データ列, color='mediumorchid')
空の両端キュー	collections.deque()
オブジェクトが辞書	isinstance(obj, dict)
ヒストグラムの色をオレンジレッドに設定する	plt.hist(データ列, color='orangered')
リストとリストについての散布図に赤い四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c='r')
データフレームのカラムの中に文字列と文字列があるか調べる	df[col].isin([value, value2])
書き込み用にBOM付きでファイルをオープンする]	open(filepath, mode='w', encoding='utf_8_sig')
ヒストグラムの色をアクアマリンに設定する	plt.hist(データ列, color='aquamarine')
データ列が何時か確認する	ds.dt.hour
ヒストグラムの色をミディアムバイオレットレッドに設定する	plt.hist(データ列, color='mediumvioletred')
データフレームの欠損値を最小値で置き換える	df.fillna(df.min())
明るいの色を赤色に設定する	plt.plot(xdata, ydata, linestyle='bright', color='r')
列をキーにして二つのデータフレームを結合する	pd.merge(df, df2, on=column)
＜オプション＞マーカーをダイアモンドに変更する	marker = 'D'
データフレームのcollをフォーマットを使って日付データに変換する	pd.to_datetime(df[col], format='%Y-%m-%d')
＜オプション＞グラフの色をダークマゼンタに指定する	color = 'darkmagenta'
横棒グラフを描画し、、幅をxに設定する	plt.barh(ラベル列, データ列, width=x)
ヒストグラムを描画して、その色を耐火レンガに設定する	plt.hist(データ列, color='firebrick')
データフレームの先頭を見る	df.head()
selectorsでマスクされたシーケンスの要素を取り出す	itertools.compress(iterable, selectors=iterable2)
リストとリストについての散布図にカラーコードの丸マーカーを描画する	plt.plot(xdata, ydata, marker='o', c=rgb)
折れ線グラフの左三角マーカーを黄色くする	plt.plot(データ列, データ列2, marker='<', markerfacecolor='y')
に水平方向の一点鎖線を付ける	plt.axhline(y=0, linestyle='dashbot')
＜オプション＞グラフの色をシアンに設定する	color = 'cyan'
日付データが日付データより後ろかどうか調べる	aDate > aDate2
２つのデータフレームを列をキーとして左結合する	pd.merge(df, df2, on=column, how='left')
折れ線グラフを描画して色をピーチパフにセットする	plt.plot(データ列, データ列2, color='peachpuff')
リストをひとつ置きに取り出す	aList[::2]
整数nがタプルのどれかか調べる	n in aTuple
スピアマン相関係数でデータフレームの相関行列	df.corr(method='spearman')
ヒストグラムを描画してその色をライトスレイグレーに指定する	plt.hist(データ列, color='lightslategray')
エンコーディングを知る	sys.getdefaultencoding()
ファイルパスが存在するか調べる	os.path.exists(filepath)
黄色色の線グラフを描画する	plt.plot(データ列, データ列2, color='yellow')
出力ストリームにxを文字列にして書き込む	f.write(str(x))
データフレームを'A'列の値によってグループ化して、列挙する	[(name, group) for name, group in df.groupby('A')]
折れ線グラフに赤い三角マーカーを描画する	plt.plot(データ列, データ列2, marker='^', markerfacecolor='r')
タプルと列をペアリングする	itertools.zip_longest(iterable, iterable2)
データフレームの中のカラムを中央値でビン分割する	pd.qcut(df[col], 2)
オプションで、出力先を標準出力に変更する	file = sys.stdout
列をキーにして二つのデータフレームを右結合する	pd.merge(df, df2, on=column, how='right')
書式をargsを引数としてフォーマットする	formatText.format(*args)
ヒストグラムの色をライトグレーに設定する	plt.hist(データ列, color='lightgray')
今日の日付を見る	datetime.date.today()
二つの最小値	min(x, y)
xが1、もしくは2、もしくは3に等しいか調べる	x == 1 or x == 2 or x == 3
＜オプション＞スノー色を使う	color = 'snow'
浮動小数点数の余弦	math.cos(x)
散布図をカラーコードのダイアモンドマーカーで描画する	plt.plot(xdata, ydata, marker='D', c=rgb)
折れ線グラフの丸マーカーのサイズをnに設定する	plt.plot(データ列, データ列2, marker='o', markersize=n)
キューの先頭に要素を追加する	deq.appendleft(element)
ヒストグラムの色をローングリーンに変更する	plt.hist(データ列, color='lawngreen')
リストとリストについての散布図にカラーコードの四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c=rgb)
カウンタの全数	aCounter.total()
ヒストグラムの色をサーモンに設定する	plt.hist(データ列, color='salmon')
＜オプション＞カンマをセパレータで使う	sep = ','
文字列を下線付きでプリントする	print(f'\033[4m{value}\033[0m')
折れ線グラフのスタイルを点線に変更する	plt.plot(データ列, データ列2, linestyle='dotted')
データ列の第一四分位数	ds.quantile(0.25)
startからendの範囲のヒストグラムを用いてデータ列を描画する	plt.hist(データ列, range=(start, end))
浮動小数点数を文字列にする	str(x)
ヒストグラムの色をライトブルーに設定する	plt.hist(データ列, color='lightblue')
Pandasでデータ列を日付データに変換する	pd.to_datetime(ds)
データフレームのカラムの分散	df[col].var()
折れ線グラフのマーカーを▽印にする	plt.plot(データ列, データ列2, marker='v')
ミディアムアクアマリン色のヒストグラムを描画する	plt.hist(データ列, color='mediumaquamarine')
データ列が正規分布からどれだけ、尖っているか見る	ds.skew()
文字列全体を複数行対応として正規表現にマッチさせる	re.fullmatch(pattern, s, flags=re.MULTILINE)
データフレームの列の欠損値をメディアンに変更する	df[col].fillna(df[col].median())
スクリプトの名前	sys.argv[0]
文字列全体がパターンにケースを無視してマッチするか見る	re.fullmatch(pattern, s, flags=re.IGNORECASE)
データフレームのリスト列の欠損値を最頻値で置換する	df[aList].fillna(df[aList].mode().iloc[0])
散布図に黒色の星マーカーを使う	plt.plot(xdata, ydata, marker='*', c='k')
データフレームのカラムをヒストグラムにする	plt.hist(df[column])
＜オプション＞菱形印を描画する	marker = 'D'
最小値でデータフレームの未入力値を補う	df.fillna(df.min())
ヒストグラムのビン数をする	plt.hist(データ列, bins=n)
ファイルの絶対パス	os.path.abspath(filepath)
青緑色の線グラフを描画する	plt.plot(データ列, データ列2, color='teal')
線グラフを描画して、その色をピーチパフに指定する	plt.plot(データ列, データ列2, color='peachpuff')
折れ線グラフを描画して、その色をフクシアに変更する	plt.plot(データ列, データ列2, color='fuchsia')
タン色のヒストグラムを描画する	plt.hist(データ列, color='tan')
明るい色の折れ線グラフを描画し、その線幅をnに設定する	plt.plot(xdata, ydata, linewidth=n, color='bright')
コーンフラワーブルー色の折れ線グラフを描画する	plt.plot(データ列, データ列2, color='cornflowerblue')
データフレームのリストカラムの空文字をドロップする	df[aList].replace('', np.nan).dropna()
ヒストグラムの色をダークグレーに設定する	plt.hist(データ列, color='darkgray')
ヒストグラムを描画して、その色をナバホホワイトに変更する	plt.hist(データ列, color='navajowhite')
文字列中に部分文字列が含まれない	sub not in s
文字列の開始位置以降が部分文字列で始まる	s.startswith(sub, start)
＜オプション＞ヘッダをnamesに設定する	header = names
散布図に黒い右三角マーカーを使う	plt.plot(xdata, ydata, marker='>', c='k')
実線グラフを描画する	plt.plot(データ列, データ列2, linestyle='solid')
ヒストグラムの色を青緑に設定する	plt.hist(データ列, color='teal')
＜オプション＞グラフの色をデピンクに変更する	color = 'deeppink'
ヒストグラムを描画してその色をゴールドに設定する	plt.hist(データ列, color='gold')
nをn2で割った結果の切り上げ	(n + n2 - 1) // n2
ベクトルを一次元化する	aArray.flatten()
日付時刻データが木曜日か調べる	aDatetime.weekday() == 3
折れ線グラフの右三角マーカーの大きさをnに設定する	plt.plot(データ列, データ列2, marker='>', markersize=n)
＜オプション＞ダークバイオレットにグラフの色を設定する	color = 'darkviolet'
スノー色の線グラフを描画する	plt.plot(データ列, データ列2, color='snow')
ファイルパスをオープンして]、読み込みストリームを見る	open(filepath, mode='r')
＜オプション＞スラグレー色を使う	color = 'slategrey'
折れ線グラフの色をミディアムターコイズに設定する	plt.plot(データ列, データ列2, color='mediumturquoise')
リストとリストについての散布図に黒い左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<', c='k')
ファイルのフォルダ名を見る	os.path.dirname(filepath)
ドジャーブルー色の線グラフを描画する	plt.plot(データ列, データ列2, color='dodgerblue')
データ列を100の位で丸める	ds.round(-2)
折れ線グラフの色をゴールドに設定する	plt.plot(データ列, データ列2, color='gold')
オブジェクトは集合型か調べる	isinstance(obj, set)
多い順番にカウンタを列挙する	aCounter.most_common()
整数nを符号付きで長さn2のバイト列に変換する	n.to_bytes(length=bytesize, byteorder='big', signed=True)
折れ線グラフに大きさnのバツ印を描画する	plt.plot(データ列, データ列2, marker='x', markersize=n)
配列を縦軸、数列をx軸として、大きさnの散布図をプロットする	plt.scatter(xdata, ydata, s=n)
折れ線グラフに大バツマーカーを加える	plt.plot(データ列, データ列2, marker='X')
データフレームの各次元の大きさを見る	df.shape
リストとリストについての散布図に文字列という補足用のラベルを付ける	plt.scatter(xdata, xdata, label=s)
データフレームを100の位で丸めて、整数にする	df.round(-2).astype(int)
データフレームを100の位で丸める	df.round(-2)
赤い色差別ないの折れ線グラフを描画する	plt.plot(xdata, ydata, linestyle='colorblind', color='r')
実数が整数か調べる	x.is_integer()
データ列の中にいくつ文字列があるか数える	ds.isin([value]).sum()
＜オプション＞グラフの色をシャルトリューズに変更する	color = 'chartreuse'
リストをひとつ飛ばしで取り出す	aList[::2]
グラフに凡例を付ける	plt.legend()
リストとリストについての散布図に黒い三角マーカーを描画する	plt.plot(xdata, ydata, marker='^', c='k')
色差別ないを描き、、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', color=rgb)
year年month月day日hour時を日付時刻に変換する	datetime.datetime(year=year, month=month, day=day, hour=hour)
プロットの描画で淡いカラーパレットを使う	sns.set(pallete='muted')
実数の逆正接	math.atan(x)
データフレームを二つの列の値によってグループ化する	df.groupby(['A', 'B'])
＜オプション＞改行コードを旧Macにする	newline = '\r'
データフレームを二つの列によってソートして、更新する	df.sort_values(by=['A', 'B'], inplace=True)
配列とリストについての散布図に黒色の左三角マーカーを描く	plt.plot(xdata, ydata, marker='<', c='k')
＜オプション＞モカシンにグラフの色を変更する	color = 'moccasin'
区間数nのヒストグラムを描画する	plt.hist(データ列, bins=n)
二次元リストを転置する	[list(x) for x in list(zip(*aList))]
マップの項目名に対応した値	aDict.get(key)
二つのデータフレームを異なる列をキーとして右結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
リストとリストについて散布図を描画して、色を淡いに変更する	plt.plot(xdata, ydata, c='muted')
nが5で割り切れるかどうか調べる	n % 5 == 0
文字列が全て数字か調べる	s.isdigit()
日付データと日付データの時間差を秒数で求める	(aDate - aDate2).total_seconds()
データフレームを二つの列の値によってグループ化して、列挙する	[(name, group) for name, group in df.groupby(['A', 'B'])]
実数の仮数	math.frexp(x)[0]
＜オプション＞グラフの色をダークスラテグレーに設定する	color = 'darkslategray'
データフレームを二つの列によって並べ直す	df.sort_values(by=['A', 'B'])
データフレームの列の値がxかつ列がx2である行を抽出する	df[(df[column] == x) & (df[column2] == x2)]
イテラブルを文字列リストに変換して、空白で連結する	' '.join(map(str, iterable))
＜オプション＞淡いピンク色色を用いる	color = 'lightpink'
実数の仮数部	math.frexp(x)[0]
両端キュー中の要素のインデックス	deq.index(element)
文字列を代数計算の変数に変換する	sympy.Symbol(s)
ゼロ埋めされたブール型の配列	np.zeros(要素数, dtype=np.int32)
リストとリストの青いパステル調のグラフを描画する	plt.plot(xdata, ydata, linestyle='pastel', color='b')
データフレームを列名リストによってソートし、、更新する	df.sort_values(by=column, inplace=True)
＜オプション＞読み込む行番号をnamesで指定する	usecols = names
折れ線グラフの色を真紅に設定する	plt.plot(データ列, データ列2, color='crimson')
データ列とリストの散布図に赤い三角マーカーを描く	plt.plot(xdata, ydata, marker='^', c='r')
改行する	print()
ヒストグラムを描画して、その色をアイボリーに設定する	plt.hist(データ列, color='ivory')
＜オプション＞リネン色を使う	color = 'linen'
リストとリストのカラーコードの淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color=rgb)
イテラブルをワンホット・ベクトルに変換する	pd.get_dummies(iterable)
プラットホームがLinux	sys.platform.startswith('linux')
昨日の日付を使う	datetime.date.today() - datetime.timedelta(days=1)
無限大	math.inf
データフレームをエクセルファイルファイルでJSONLファイルに保存する	df.to_excel(filename)
ファイルパスを書き込み用にオープンする]	open(filepath, mode='w')
辞書に別の辞書の項目を更新する	aDict.update(aDict2)
文字列に日本語が含まれるか	re.search('[あ-んア-ン\u4E00-\u9FD0]', s)
ダークカーキにヒストグラムの色を設定する	plt.hist(データ列, color='darkkhaki')
タプルのn番目の	aTuple[n]
カラーバーをプロットする	plt.colorbar()
十六進数字を全て使う	string.hexdigits
現在の作業ディレクトリ	os.getcwd()
双方向キューの大きさ	len(deq)
タプルのn番目からn2番目まで	aTuple[n:n2]
第２コマンド引数	sys.argv[1]
ライトイエロー色の線グラフを描画する	plt.plot(データ列, データ列2, color='lightyellow')
nがn2以下、またはn3以上か確認する	n <= n2 or n >= n3
リストとリストについての散布図に▲マーカーを描画する	plt.plot(xdata, ydata, marker='^')
文字列の両端から余分な空白を除く	s.strip()
TSVファイルを読み込む	pd.read_csv(filename, sep='\t')
二つの集合のいずれか一方だけの集合	aSet.symmetric_difference(aSet2)
リストとリストについて散布図をプロットしてマーカーの色を暗いに設定する	plt.plot(xdata, ydata, c='dark')
ガンマ関数	math.gamma(x)
折れ線グラフのポイントマーカーを赤くする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='r')
淡い色のマーカーで散布図を重なりを見やすく描画する	plt.plot(xdata, ydata, c='muted', alpha=0.5)
コロンで区切って二つの文字列をプリントする	print(value, value2, sep=':')
データフレームのリストカラムを10の位で丸める	df[aList].round(-1)
データフレームのインデックスをリセットする	df.reset_index()
２つのカウンタのいずれかに含まれる要素を求める	aCounter | aCounter2
２つの文字列をタブで区切って表示する	print(value, value2, sep='\t')
nにn2をかけた値をnとする	n *= n2
ディムグレーにヒストグラムの色を変更する	plt.hist(データ列, color='dimgray')
いつまでもnからstep間隔でカウントアップする	itertools.count(start=n, step=step)
左にn個分両端キューの要素を回転させる	deq.rotate(-n)
散布図を三角マーカーを用いて描画する	plt.plot(xdata, ydata, marker='^')
year年month月day日hour時のタイムスタンプをオブジェクト化する	datetime.datetime(year=year, month=month, day=day, hour=hour)
データフレームを関数の値によってグループ化し要約統計量を求める	df.groupby(関数).describe()
nの三乗	n ** 3
データ列の欠損値を直後の値で埋める	ds.fillna(method='bfill')
線グラフの色をライトイエローに指定する	plt.plot(データ列, データ列2, color='lightyellow')
折れ線グラフのクロス印の線幅をnにセットする	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
データフレームを'A'列によってソートして、更新する	df.sort_values(by='A', inplace=True)
nはn2	n == n2
折れ線グラフの丸印を黒色にする	plt.plot(データ列, データ列2, marker='o', markerfacecolor='k')
イテラブルの各要素に対して、predicateFuncが真であれば、その要素を出力する	itertools.takewhile(predicateFunc, iterable)
nが2で割り切れないか	n % 2 == 1
折れ線グラフの左三角マーカーのサイズをnに変更する	plt.plot(データ列, データ列2, marker='<', markersize=n)
イテラブルを文字列として連結する	''.join(map(str, iterable))
ヒストグラムを描画して、その色をピーチパフに変更する	plt.hist(データ列, color='peachpuff')
データフレームの末尾n行を抽出する	df.tail(n)
数列とリストの破線グラフを描画して色を色差別ないに設定する	plt.plot(xdata, ydata, linestyle='dash', color='colorblind')
リストとリストについて破線グラフを描画して、その色を明るいに変更する	plt.plot(xdata, ydata, linestyle='dash', color='bright')
データフレームのNaNを中央値に設定する	df.fillna(df.median())
折れ線グラフの大バツマーカーを黒くする	plt.plot(データ列, データ列2, marker='X', markerfacecolor='k')
＜オプション＞オレンジレッド色を使う	color = 'orangered'
アルファベットの文字列	string.ascii_letters
＜オプション＞文字列の示すエンコーディングを用いる	encoding = s
日付時刻データからn秒を減らす	aDatetime - datetime.timedelta(seconds=n)
xとyの商と余りを同時に求める	divmod(x, y)
文字列はタプルに含まれないか	element not in aTuple
最大長nの双方向キューを作る	collections.deque(maxlen=n)
文字列を黒色で表示する	print(f'\033[30m{value}\033[0m')
赤いヒストグラムを描画する	plt.hist(データ列, color='r')
線グラフの色を貝殻に指定する	plt.plot(データ列, データ列2, color='seashell')
ヒストグラムの色をロイヤルブルーに設定する	plt.hist(データ列, color='royalblue')
文字列がアルファベットか調べる	s.isalpha()
折れ線グラフに線幅nのバツマーカーを描画する	plt.plot(データ列, データ列2, marker='x', markeredgewidth=n)
空文字	''
データフレームの欠損値をxに設定する	df.fillna(x)
＜オプション＞グリーンイエローにグラフの色を設定する	color = 'greenyellow'
リストとリストについて散布図を描画して、マーカーの色を淡いに設定する	plt.plot(xdata, ydata, c='muted')
破線グラフを描画する	plt.plot(データ列, データ列2, linestyle='dashed')
ファイル名がTSVファイルか調べる	filename.endswith('.tsv')
列名を指定された列の名前一覧に置き換える	df.columns = columns
折れ線グラフを描画してその色をライトグレーに指定する	plt.plot(データ列, データ列2, color='lightgrey')
ベクトルの形状	aArray.shape
集合から別の集合の要素を全て取り除く	aSet.difference_update(aSet2)
レモンシフォン色のヒストグラムを描画する	plt.hist(データ列, color='lemonchiffon')
ヒストグラムを描画して、その色をダークスレートブルーに指定する	plt.hist(データ列, color='darkslateblue')
実数の逆双曲線余弦	math.acosh(x)
タプルをひとつ置きに取り出す	aTuple[::2]
リストを色差別ない色のヒストグラムで描画する	plt.hist(xdata, color='colorblind')
オブジェクトが集合クラス	isinstance(obj, set)
データフレームのカラムの中にある文字列の合計をカウントする	df[col].isin([value]).sum()
文字列を右から空白で分割する	s.rsplit()
リストとリストの濃いグラフを描画し、、その色を青にする	plt.plot(xdata, ydata, linestyle='deep', color='b')
配列を暗い色のヒストグラムで描画する	plt.hist(xdata, color='dark')
ヒストグラムの色をダークバイオレットに設定する	plt.hist(データ列, color='darkviolet')
まとめてValueMapでデータ列を置き換える	ds.replace(ValueMap)
データフレームの列が文字列で始まる行を抽出する	df[df[column].str.startswith(s)]
リストと配列で色差別ないグラフを描画して、その線幅をnに設定する	plt.plot(xdata, ydata, linestyle='colorblind', linewidth=n)
折れ線グラフを描画して色をダークゴールデンロッドに設定する	plt.plot(データ列, データ列2, color='darkgoldenrod')
リストのn番目に文字列を差し込む	aList.insert(n, element)
カラーコードのポイントマーカーで散布図を描画する	plt.plot(xdata, ydata, marker='.', c=rgb)
ヒストグラムを描画して、その色をダークスラテグレーに設定する	plt.hist(データ列, color='darkslategray')
ピンク色のヒストグラムを描画する	plt.hist(データ列, color='pink')
＜オプション＞ミントクリームを使う	color = 'mintcream'
折れ線グラフのマーカーを左三角印にする	plt.plot(データ列, データ列2, marker='<')
コーンフラワーブルー色のヒストグラムを描画する	plt.hist(データ列, color='cornflowerblue')
折れ線グラフの色をコーラルに指定する	plt.plot(データ列, データ列2, color='coral')
＜オプション＞ミッドナイトブルー色を使用する	color = 'midnightblue'
日付時刻データを数値に変換する	aDatetime.timestamp()
グラフを描画する準備をする	from sympy import N
列の値にデータフレームをグループ化して、それぞれのグループ毎の平均値を求める	df.groupby(column).mean()
散布図にカラーコードの上三角マーカーを使う	plt.plot(xdata, ydata, marker='^', c=rgb)
文字列中に部分文字列がいくつか含まれるか調べる	s.count(sub)
散布図を明るい色で描画する	plt.plot(xdata, ydata, c='bright')
折れ線グラフを点線として描画する	plt.plot(データ列, データ列2, linestyle='dotted')
折れ線グラフを描画してその色をピンクに設定する	plt.plot(データ列, データ列2, color='pink')
折れ線グラフを描画して、色をチョコレートに設定する	plt.plot(データ列, データ列2, color='chocolate')
再帰エラーを未然に防ぐ	sys.setrecursionlimit(1000000)
ヒストグラムの色をトマトに変更する	plt.hist(データ列, color='tomato')
縦棒グラフを描画する	plt.bar(ラベル列, データ列)
nの無限の整数イテラブルを得る	itertools.repeat(n)
変数を緑色でプリントする	print(f'\033[32m{value}\033[0m')
変数が無限大に近づくときの数式の極限値を求める	sympy.limit(e, z, oo)
データフレームのカラムの中にいくつ欠損値が存在するかカウントする	df[col].isna().sum()
ヒストグラムを描画して、その色をデピンクに設定する	plt.hist(データ列, color='deeppink')
折れ線グラフに描画して印を四角印にする	plt.plot(データ列, データ列2, marker='s')
リストと配列の折れ線グラフをuntitledとラベル付けしてプロットする	plt.plot(xdata, ydata, label=untitled)
データフレームを各列毎にグループ化して、列の最大値を求める	df.groupby(column)[column2].max()
データフレームの中に日付データと文字列がいくつあるか求める	df.isin([value, value2]).sum()
行列の累積積を算出する	np.cumprod(aArray)
データ列を1000の位で四捨五入する	ds.round(-3)
イテラブルとイテラブルを連結する	itertools.chain(iterable, iterable2)
リストとデータ列についての散布図に左三角マーカーを描画する	plt.plot(xdata, ydata, marker='<')
ヒストグラムの色をダークシアンに変更する	plt.hist(データ列, color='darkcyan')
＜オプション＞シスルを使う	color = 'thistle'
線グラフの色を青に設定する	plt.plot(データ列, データ列2, color='blue')
ファイル名がテキストファイル	filename.endswith('.txt')
日付時刻データををn日後に進める	aDatetime + datetime.timedelta(days=n)
四分位数でリストをビン分割する	pd.qcut(aList, 4)
＜オプション＞グラフの色をイエローグリーンに設定する	color = 'yellowgreen'
データフレームを列によってソートする	df.sort_values(by=column)
ヒストグラムを描画して、色を白くする	plt.hist(データ列, color='w')
データフレームのリスト列の欠損値を直前の値に設定する	df[aList].fillna(method='ffill')
ヒストグラムでカラーマップを使う	"plt.hist(データ列, color=plt.get_cmap(""Spectral""))"
浮動小数点数を小数点以下で丸める	round(x, n)
モジュールを検索するパス	sys.path
ディレクトリを使う	os.getcwd()
ヒストグラムの色をスカイブルーに設定する	plt.hist(データ列, color='skyblue')
折れ線グラフの色をタンに設定する	plt.plot(データ列, データ列2, color='tan')
変数について数式の積分を求める	sympy.integrate(e, z)
文字列全体が正規表現にASCII限定としてマッチするか確認する	re.fullmatch(pattern, s, flags=re.ASCI)
折れ線グラフの▽マーカーを赤くする	plt.plot(データ列, データ列2, marker='v', markerfacecolor='r')
リストと数列についての散布図に赤いバツマーカーを描く	plt.plot(xdata, ydata, marker='x', c='r')
淡い色のヒストグラムでリストを描く	plt.hist(xdata, color='muted')
ヒストグラムの色を青くする	plt.hist(データ列, color='b')
日付データにn時間を加える	aDate + datetime.timedelta(hours=n)
昇順にデータフレームを'A'列と'B'列によって並べ直し、、更新する	df.sort_values(by=['A', 'B'], ascending=True, inplace=True)
整数nはリストのどれかか	n in aList
積み上げ横棒グラフを描く	"plt.barh(ラベル列, データ列, bottom=データ列2, color=""red"")"
データフレームを各列毎にグループ化して、列の標準偏差を求める	df.groupby(column)[column2].std()
＜オプション＞グラフの色をスレートブルーに設定する	color = 'slateblue'
暗い色のマーカーで散布図を描く	plt.plot(xdata, ydata, c='dark')
データフレームのカラムを100の位で丸めて整数型にする	df[col].round(-2).astype(int)
＜オプション＞ベージュ色を使う	color = 'beige'
データフレームのリストカラムの標準偏差を求める	df[aList].std()
＜オプション＞スレートブルーにグラフの色を設定する	color = 'slateblue'
折れ線グラフに下三角印を用いる	plt.plot(データ列, データ列2, marker='v')
パステル調の色の折れ線を描画して、線幅をnに変更する	plt.plot(xdata, ydata, linewidth=n, color='pastel')
グラフの横軸にuntitledというラベルを付ける	plt.xlabel(untitled)
両端キューから部分を取り出す	collections.deque(itertools.islice(deq, start, end))
モカシン色の線グラフを描画する	plt.plot(データ列, データ列2, color='moccasin')
破線グラフの色を明るいに設定する	plt.plot(xdata, ydata, linestyle='dash', color='bright')
折れ線グラフを描画してその色を小麦色に設定する	plt.plot(データ列, データ列2, color='wheat')
十六進文字列を浮動小数点数に変換する	float.fromhex(十六進表記の文字列)
０で全要素を初期化された３２ビット整数型の行列	np.zeros(行数, 列数, dtype=np.int16)
ヒストグラムを描画して、色をオリーブに設定する	plt.hist(データ列, color='olive')
文字列中に非空白が含まれるか調べる	any(not c.isspace() for c in s)
双方向キューのn番目	deq[n]
濃いの色を赤くする	plt.plot(xdata, ydata, linestyle='deep', color='r')
＜オプション＞色をフローラルホワイトに設定する	color = 'floralwhite'
数式の部分分数化を行う	sympy.apart(e)
文字コードを文字に変換する	chr(unicode)
＜オプション＞文字コードをBOM付きに変更する	encoding = 'utf_8_sig'
＜オプション＞白色を使う	color = 'white'
オプションで、出力先を標準出力に設定する	file = sys.stdout
現在のタイムスタンプ	int(time.time())
折れ線グラフを描画して、その色をターコイズに設定する	plt.plot(データ列, データ列2, color='turquoise')
左三角マーカーとして散布図を描く	plt.plot(xdata, ydata, marker='<')
ファイルパスをオープンして]、バイナリ書き込みストリームを見る	open(filepath, mode='wb')
双方向キュー中の文字列のインデックスを求める	deq.index(element)
データフレームのリストカラムの欠損値を中央値で埋める	df[aList].fillna(df[aList].median())
イテラブルからn個サンプリングする	random.sample(iterable, k=n)
文字列TSVからCSVファイルをn番目のカラムをインデックスとして読み込む	pd.read_csv(filename, index_col=n)
整数nを十六進表現に変換する	hex(n)
散布図にカラーコードの大バツマーカーを用いる	plt.plot(xdata, ydata, marker='X', c=rgb)
線グラフの色をミディアムアクアマリンに設定する	plt.plot(データ列, データ列2, color='mediumaquamarine')
双方向キューをタプルに変換する	tuple(deq)
辞書の値に要素が含まれていないか調べる	element not in aDict.values()
＜オプション＞グラフの色をオールドレースに設定する	color = 'oldlace'
フォレストグリーン色のヒストグラムを描画する	plt.hist(データ列, color='forestgreen')
分割数nで列を分割する	pd.cut(ds, n)
二進文字列を整数に変換する	int(s, 2)
エポック秒のデータフレームのcollから日付データに変換する	pd.to_datetime(df[col], unit='s', utc=True)
折れ線グラフを描画して、その色をディムグレーに設定する	plt.plot(データ列, データ列2, color='dimgray')
＜オプション＞ローングリーンを用いる	color = 'lawngreen'
データフレームの中にいくつNaNがあるか数える	df.isna().sum()
0からnまでの整数列	list(range(n+1))
リストとデータ列についての散布図に黒い四角マーカーを描画する	plt.plot(xdata, ydata, marker='s', c='k')
折れ線グラフに黒い星印を描画する	plt.plot(データ列, データ列2, marker='*', markerfacecolor='k')
nを符号なしでバイナリに変換する	n.to_bytes(length=bytesize, byteorder='big')
データフレームを列によって並べ直して、新しいインデックスを加える	df.sort_values(columns).reset_index()
ファイル名がJSONファイルか調べる	filename.endswith('.json')
辞書から項目名の値をエラーなく参照する	aDict.get(key, None)
データ列を折れ線グラフに描画してマーカーを右三角にする	plt.plot(データ列, データ列2, marker='>')
直前の値でデータフレームの欠損値を埋める	df.fillna(method='ffill')
イテラブルをダミー変数に変換する	pd.get_dummies(iterable)
CSVを読み込む	pd.read_csv(filename, sep=',')
パターンにマッチした文字列を新しい文字列で置き換える	re.sub(pattern, newsub, s)
nが一桁の整数か調べる	-9 <= n <= 9
データ列の値が欠損値かどうか調べる	ds.isna()
列の最大幅をnに設定する	pd.set_option('max_colwidth', n)
配列の最小値を求める	np.min(aArray)
折れ線グラフの色をライトスレイグレーに設定する	plt.plot(データ列, データ列2, color='lightslategrey')
データフレームをJSONLファイルから読み込む	pd.read_json(filename, orient='records', lines=True)
折れ線グラフを描画してその色をライトシアンに設定する	plt.plot(データ列, データ列2, color='lightcyan')
バイオレット色の線グラフを描画する	plt.plot(データ列, データ列2, color='violet')
＜オプション＞星マーカーを描画する	marker = '*'
線グラフを描画して、色をスカイブルーに設定する	plt.plot(データ列, データ列2, color='skyblue')
ヒストグラムの色をチョコレートに設定する	plt.hist(データ列, color='chocolate')
日本語フォントをグラフで表示できるようにする	sns.set(font='IPAexGothic')
最大長のある両端キュー	collections.deque(maxlen=n)
異なる列をキーとして二つのデータフレームを内部結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='inner')
辞書の項目名と値を入れ替える	{v: k for k, v in aDict.items()}
数値の数値を計算する	float(e)
線グラフを描画して、その色をライトスチールブルーに設定する	plt.plot(データ列, データ列2, color='lightsteelblue')
折れ線グラフに黒い丸マーカーを描画する	plt.plot(データ列, データ列2, marker='o', markerfacecolor='k')
プロットで使用するy軸のラベルをuntitledに指定する	plt.ylabel(untitled)
＜オプション＞グラフの色をライトスカイブルーに設定する	color = 'lightskyblue'
配列の要素ごとに加算する	aArray + aArray2
折れ線グラフの色をトマトに設定する	plt.plot(データ列, データ列2, color='tomato')
変数名をキーとしてマップ	dict(name=element)
折れ線グラフを描画して、その色をアイボリーに設定する	plt.plot(データ列, データ列2, color='ivory')
リストとリストの黒い淡いグラフを描画する	plt.plot(xdata, ydata, linestyle='muted', color='k')
Pandasで、データフレームのカラムを日付データに変換し、データフレームのインデックスにする	df.index = pd.DatetimeIndex(pd.to_datetime(df[col]))
空のキュー	collections.deque()
データフレームのリストカラムの欠損値を直後の値に変更する	df[aList].fillna(method='bfill')
ファイルを一行ずつ読み込む	f.readline()
ケンドールでデータフレームの列と列の相関行列	df[[column, column2]].corr(method='kendall')
n2がn以上かつ、n3以下かどうか調べる	n <= n2 and n2 <= n3
辞書からキーの値かもしくは要素を得る	aDict.get(key, element)
ダークブルー色のヒストグラムを描画する	plt.hist(データ列, color='darkblue')
列の第三四分位数	ds.quantile(0.75)
文字列の右側	s[-1]
折れ線グラフを描画して、その色をミディアムスプリンググリーンに設定する	plt.plot(データ列, データ列2, color='mediumspringgreen')
パステル調のグラフの線幅をnに指定する	plt.plot(xdata, ydata, linestyle='pastel', linewidth=n)
透明度alphaの折れ線グラフを描画する	plt.plot(xdata, ydata, alpha=alpha)
文字列をシアンにする	f'\033[36m{value}\033[0m'
ヒストグラムを描画する	plt.hist(データ列)
ヒストグラムを描画して、その色をコーンフラワーブルーに設定する	plt.hist(データ列, color='cornflowerblue')
タイムスタンプデータからn週間分減算する	aDatetime - datetime.timedelta(weeks=n)
実数以下の最大の整数	math.floor(x)
組のn番目の	aTuple[n]
実数の双曲線正接	math.tanh(x)
線グラフを描画して、その色をライムグリーンに設定する	plt.plot(データ列, データ列2, color='limegreen')
データフレームのリストカラムの中にいくつ欠損値があるかカウントする	df[aList].isna().sum()
オブジェクトから属性を取り除く	delattr(obj, プロパティ名)
＜オプション＞色を耐火レンガに設定する	color = 'firebrick'
＜オプション＞グラフの色をサンディーブラウンに変更する	color = 'sandybrown'
データ列の空文字を欠損値に変換し、ドロップする	ds.replace('', np.nan).dropna()
データフレームを各列と列の組み合わせ毎に分類して、個数を計算する	df.groupby([column, column2], as_index=False).count()
暗い色でリストについてのヒストグラムを描画する	plt.hist(xdata, color='dark')
ヒストグラムを描画してその色をライトスカイブルーに設定する	plt.hist(データ列, color='lightskyblue')
ヒストグラムの色を淡いピンク色に設定する	plt.hist(データ列, color='lightpink')
書き込みできるように文字コードtextでファイルパスを開く]	open(filepath, mode='w', encoding=text)
プラットホームがWindowsか調べる	sys.platform.startswith('win32')
ヒストグラムの色をラベンダーブラッシュに設定する	plt.hist(データ列, color='lavenderblush')
ヒストグラムを描画して、その色をタンに設定する	plt.hist(データ列, color='tan')
ハローワールドをプリントする	print('Hello World')
折れ線グラフの色をサンディーブラウンに指定する	plt.plot(データ列, データ列2, color='sandybrown')
標準出力を用いる	sys.stdout
散布図を黒いバツマーカーとして描く	plt.plot(xdata, ydata, marker='x', c='k')
濃いカラーパレットをプロットの描画で用いる	sns.set(pallete='deep')
＜オプション＞三2ビット整数型を使う	dtype = np.int16
淡いグラフの色を赤にする	plt.plot(xdata, ydata, linestyle='muted', color='r')
データフレームのカラムの曜日数を求める	df[col].dt.dayofweek
JSON形式の文字列をデータに変換する	json.loads(b.decode('unicode-escape'))
文字列の接頭辞が部分文字列か調べる	s.startswith(sub)
出力ストリーム全体を行分割して読む	f.readlines()
＜オプション＞グラフの色をピンクにセットする	color = 'pink'
ブラウン色の線グラフを描画する	plt.plot(データ列, データ列2, color='brown')
＜オプション＞グラフの色をダークサーモンに設定する	color = 'darksalmon'
降順に破壊的にデータフレームを二つの列を用いてソートする	df.sort_values(by=['A', 'B'], ascending=False, inplace=True)
データフレームの中に文字列があるか調べる	df.isin([value])
文字列の先頭でパターンに大文字・小文字を無視してマッチさせる	re.match(pattern, s, flags=re.IGNORECASE)
要素が集合に含まれないか調べる	element not in aSet
積み上げ棒を描画する	"plt.bar(ラベル列, データ列, bottom=データ列2, color=""red"")"
散布図に黒い丸マーカーを使う	plt.plot(xdata, ydata, marker='o', c='k')
点線に折れ線グラフのスタイルを設定する	plt.plot(データ列, データ列2, linestyle='dotted')
リストとリストについての散布図にカラーコードの大バツマーカーを描画する	plt.plot(xdata, ydata, marker='X', c=rgb)
Pythonパスにディレクトリを加える	sys.path.append(os.path.join(os.path.dirname(__file__), dir))
ヒストグラムを描画して、その色をインディアンレッドに指定する	plt.hist(データ列, color='indianred')
列をキーにして２つのデータフレームを内部結合する	pd.merge(df, df2, on=column, how='inner')
折れ線グラフの四角マーカーを黒くする	plt.plot(データ列, データ列2, marker='s', markerfacecolor='k')
折れ線グラフのポイントマーカーを黄色くする	plt.plot(データ列, データ列2, marker='.', markerfacecolor='y')
year年month月day日を日付時刻に変換する	datetime.datetime(year=year, month=month, day=day)
＜オプション＞グラフの色をダークシアンに設定する	color = 'darkcyan'
データフレームをタブ区切りのファイルから読む	pd.read_csv(filename, sep='\t', encoding='utf-8')
折れ線グラフを描画して、その色をパールバイオレットレッドに変更する	plt.plot(データ列, データ列2, color='palevioletred')
一点鎖線ヒストグラムを描画する	plt.hist(データ列, linestyle='dashbot')
データフレームを'A'列によってによって大きい順に並べる	df.sort_values(by='A', ascending=False)
折れ線グラフに描画して、マーカーを▽印にする	plt.plot(データ列, データ列2, marker='v')
データフレームが重複しているか調べる	df.duplicated()
文字列の大文字小文字を交換する	s.swapcase()
カラーコードのポイントマーカーをデータ列とデータ列の散布図に描く	plt.plot(xdata, ydata, marker='.', c=rgb)
行列の行列式	np.linalg.det(aArray)
辞書を計数器にする	collections.Counter(aDict)
列'A'と列'B'をキーとして二つのデータフレームを右結合する	pd.merge(df, df2, left_on=column, right_on=column2, how='right')
＜オプション＞ミディアムターコイズにグラフの色を設定する	color = 'mediumturquoise'
カラーバーを横向きに設定する	plt.colorbar(orientation='horizontal')
実数の床	math.floor(x)
散布図に▼マーカーを使う	plt.plot(xdata, ydata, marker='v')
ファイルを絶対ファイルパスに変換する	os.path.abspath(filepath)
日付時刻データが日曜日かどうか	aDatetime.weekday() == 6
＜オプション＞右三角マーカーを描画する	marker = '>'
TSVファイルを読み込む	pd.read_csv(filename, sep='\t', encoding='utf-8')