Pythonの実行を高速化する方法を一覧でまとめてみた

# はじめに

Pythonは最近とても人気で、機械学習だけでなく様々な分野で幅広く使われています。
しかし、Pythonには**実行速度が遅い**という弱点があります。
高速なC言語などと比べて**数百倍**遅く、科学計算などでは残念ながらPythonは選択肢に入りません。
しかし私はPythonが好きで、`{}`や`end`を書いたり、いちいち変数宣言なんてしたくないので、高速化する方法を調べました。

調べてみたところ、Pythonを高速化する一つ一つの方法の詳しい解説記事は見つかりました。
しかし、網羅するような逆引きのまとめがなかったので、記事を書くことにしました。


それぞれの方法を調べましたが、実際に使用したことがないものが多いため、記事で間違いがありましたら、ぜひ指摘してください。
また、ここに載っていない高速化方法などありましたら、ぜひコメント欄で教えてください。
よろしくお願いします。


# 目次

書いた内容は、規模が大きい順に並べました。




| 項番 | 項目 | 概要 |
|:-:|:-|:-|
| 1  | [1. クラスタレベル](#1-クラスタレベル)  | 複数コンピュータをつなげて分散処理する方法  |
| 2  | [2. コンピュータレベル](#2-コンピュータレベル)  | 単一PC内で高速化する方法  |
| 3  | [3. Python処理系、コンパイラレベル](#3-python処理系コンパイラレベル)  | 特定のPythonの種類、コンパイラを使用して高速化する方法  |
| 4  | [4. Pythonライブラリレベル](#4-pythonライブラリレベル)  | 高速なライブラリを使用する方法  |
| 5  | [5. コーディングレベル](#5-コーディングレベル)  | 高速に動作するようなコードを書く方法  |
| 6  | [6. 番外編：高速な他言語のプログラムを呼び出す](#6-番外編高速な他言語のプログラムを呼び出す)  | 他の高速な言語を使用する方法  |
| 7  | [7. 番外編2：ハードウェアの選択](#7-ハードウェアの選択)  | CPUやGPUなどハードウェアの選び方  |









# 1. クラスタレベル

複数のマシンを使用するクラスタレベルで分散処理することで高速化する方法です。
もうここまでくると __Python__ というプログラミング言語レベルではなくなりますが、高速化の選択肢として説明します。




### Hadoop

大量のデータを複数マシンに分散して処理させるオープンソースのプラットフォーム。
Google社内基盤技術をオープンソースとして実装したものらしいです。

https://www.fujitsu.com/jp/products/computing/storage/lib-f/tech/beginner/hadoop/#:~:text=Hadoop%EF%BC%88%E3%83%8F%E3%83%89%E3%82%A5%E3%83%BC%E3%83%97%EF%BC%89%E3%81%AF%E3%80%81%E3%83%87%E3%83%BC%E3%82%BF,%E3%81%8C%E9%80%B2%E3%82%93%E3%81%A7%E3%81%84%E3%81%BE%E3%81%99%E3%80%82

https://oss.nttdata.com/hadoop/hadoop.html

https://qiita.com/uenohara/items/8d71ce907886422734e2



### Apache Spark

カリフォルニア大学バークレー校で開発された分散処理フレームワーク。
Hadoopよりもメモリをうまく使うことで、機械学習を高速で実行できるようにしたものです。

https://atmarkit.itmedia.co.jp/ait/articles/1608/24/news014.html

https://qiita.com/Hiroki11x/items/4f5129094da4c91955bc

https://www.nvidia.com/ja-jp/deep-learning-ai/solutions/data-science/apache-spark-3/









































# 2. コンピュータレベル

1台のコンピュータの中で高速化する方法です。
高速化のアプローチとしては、並列化、GPGPUの選択があります。


## 2-1. 並列化
一つのマシンの中で、プログラムを並列化して実行して高速化する方法です。

詳しくは東京大学の情報基盤センターが無料で公開している動画がわかりやすいです。

https://www.cc.u-tokyo.ac.jp/events/lectures/materials/


<details><summary>ちなみに<strong>並行処理</strong>と<strong>並列処理</strong>がありますが、違いは詳しくはクリック</summary><div>



https://qiita.com/Kohei909Otsuka/items/26be74de803d195b37bd

https://qiita.com/4_mio_11/items/7f418ca661d9f5a2a39d

</div></details>




### Pythonライブラリを使用した並列化

Pythonのプログラムは、ライブラリを使用することで比較的簡単にできます。
ライブラリとして、`multiprocessing`、`threading`、`concurrent.futures`などがあります。
マルチプロセス、マルチスレッドを一緒に紹介している記事が多いので、区別せずにリンクを貼ります。

https://qiita.com/Toyo_m/items/992b0dcf765ad3082d0b

https://qiita.com/simonritchie/items/1ce3914eb5444d2157ac

https://tech.morikatron.ai/entry/2020/03/13/100000

https://zenn.dev/ryo_kawamata/articles/python-concurrent-thread

https://qiita.com/yuki_2020/items/ffc9f2e4f3f7cc0982f3





### MPI
分散メモリ型計算機の __プロセス間__ の通信規格らしい。
スパコンで並列処理するために使用されることが多い。

詳しくは東京大学の情報基盤センターが無料で公開している動画がわかりやすいです。

https://www.cc.u-tokyo.ac.jp/events/lectures/materials/



いわゆる __マルチプロセス__
もともとC、C++、Fortranから呼び出すものだが、Pythonからも`mpi4py`というライブラリを使用することで利用できる。


[座学「並列プログラミング入門」in 金沢 第2講　並列処理とMPIの基礎](https://www.cc.u-tokyo.ac.jp/events/lectures/X01/shiryou-2.pdf)
[座学「並列プログラミング入門」in 金沢 第4講　Hybrid並列化技法（MPIとOpenMPの応用）PDF](https://www.cc.u-tokyo.ac.jp/events/lectures/X01/shiryou-4.pdf)
[名古屋大学情報基盤センター　MPIの基礎](https://www.r-ccs.riken.jp/wp/wp-content/uploads/2020/09/katagiri190418.pdf)
[東京大学情報基盤センター　MPI基礎：並列プログラミング入門](https://www.cc.u-tokyo.ac.jp/events/lectures/141/20201013-3.pdf)
[神戸大学計算科学教育センター　MPIによる並列化実装](http://www.eccse.kobe-u.ac.jp/assets/images/simulation_school/kobe-hpc-spring-school-2018/184f6b0b792d27278301edd9436103d82fda111f.pdf)

https://qiita.com/n_scattering/items/7a412fe794a31030b0ec

https://self-development.info/%E3%80%90python%E3%80%91mpi%E3%81%AB%E3%82%88%E3%82%8B%E4%B8%A6%E5%88%97%E5%87%A6%E7%90%86%E3%81%AE%E3%81%9F%E3%82%81%E3%81%ABmpi4py%E3%82%92%E3%82%A4%E3%83%B3%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AB/

https://keichi.dev/post/mpi4py/






### OpenMP
共有メモリ型マシンで並列プログラミングを可能にするAPIです。スパコンでよく使われます。
いわゆる __マルチスレッド__
C、C++、Fortranについて標準化が行われています。
Cython経由でOpenMPを使用できるらしいですが、Pythonではあまり実用的ではなさそうです。

[座学「並列プログラミング入門」in 金沢 第3講　OpenMPの基礎PDF](https://www.cc.u-tokyo.ac.jp/events/lectures/X01/shiryou-3.pdf)
[座学「並列プログラミング入門」in 金沢 第4講　Hybrid並列化技法（MPIとOpenMPの応用）PDF](https://www.cc.u-tokyo.ac.jp/events/lectures/X01/shiryou-4.pdf)
[名古屋大学情報基盤センター　OpenMPの基礎](https://www.r-ccs.riken.jp/wp/wp-content/uploads/2020/09/katagiri190425.pdf)
[理化学研究所　OpenMPによるスレッド並列計算](http://www.eccse.kobe-u.ac.jp/assets/images/simulation_school/kobe-hpc-summer-basic-2018/KHPC2018-openmp.pdf)

https://qiita.com/tatamiya/items/d108f9e5f70b9683ef3d#cython--openmp

https://www.fixes.pub/program/978169.html

https://stackoverflow.com/questions/11368486/openmp-and-python





## 2-2. GPGPU
GPGPUとは、General Purpose GPUの略で、GPUを画像処理以外に使用する技術です。ディープラーニングやマイニングに使用されているのが有名です。
GPUは汎用性がCPUと比べて低いですが、行列計算などがとても高速です。
そのため、GPUを処理の一部で使用することで高速化が可能です。
ただし、メモリ上にある配列をGPUのメモリに移して、計算後に戻すために時間がかかるため、場合によってはより時間がかかってしまうこともあります。

### CuPy
NumPy互換のインターフェースを持ち、GPUを使うことができるライブラリです。
日本のベンチャー企業Preferred Networksが開発しました。（Chainerを作っていた会社）
おそらく一番使いやすくて有名です。
変数は明示的にプログラムでメモリ-GPU間を移動させる必要があります。

https://www.preferred.jp/ja/projects/cupy/

https://qiita.com/samacoba/items/d18e6cf09f544477aff4

https://tutorials.chainer.org/ja/10_Introduction_to_CuPy.html

https://www.kkaneko.jp/tools/win/cupy.html

https://www.slideshare.net/pfi/gtcj2018cupy-numpygpupythonpfn


### TensorFlow

ディープラーニング界の2大フレームワークの片割れです。
ディープラーニング自体テンソル同士の演算（行列同士の演算）であるため、ディープラーニング以外にも使用可能です。
GPUとCPUを使い分けることを前提にして設計されているため、メモリ-GPU間の変数の移動を自動で行ってくれます。
ただしディープラーニング以外で使用しているのをみたことがないので、情報が少なく学習が大変かもしれません。

https://www.tensorflow.org/tutorials/eager/basics?hl=ja


### PyCUDA
本来C/C++で使用するCUDAを、Pythonから呼び出せるようにバインディングしたライブラリです。
おそらくCUDAに関する知識がないと使えなさそうです。
そしてネット上にあまり情報がないです。

https://www.kkaneko.jp/tools/win/pycuda.html

https://self-development.info/pycuda%E3%81%AE%E3%82%A4%E3%83%B3%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AB%E3%80%90python-on-windows%E3%80%91/



### Numba.cuda
後に解説する`Numba`というライブラリにCUDAを使用するものが含まれているらしいです。
おそらくCUDAに関する知識がないと使えなさそうです。
ネット上にあまり情報がない。

https://yutori-datascience.hatenablog.com/entry/2014/12/29/145157

https://qiita.com/hoto17296/items/332da1d57173534c3aa7

https://numba.readthedocs.io/en/stable/cuda/index.html



































# 3. Python処理系、コンパイラレベル
普通のPythonはCPythonといって、C言語で書かれた処理系らしいです。
しかし他にもJavaで実装された`Jython`、C#で実装された`IronPython`があったり、JITコンパイラによってコンパイルを最適化して高速化してくれるものがります。
この章では、高速化してくれる処理系、コンパイラに関してまとめました。

https://qiita.com/n4mlz/items/fbadc02b7864f62b9622

↑のサイトに比較したものがわかりやすくまとめられていますが、
軽くまとめると実行速度は
`C++ > 越えられない壁 > Codon > Numba > Cython > PyPy > Cpython(デフォ)`
のようです。
また、私見ですが、元のコードをどれだけ書き換えないで済むかで比較すると、
`Cpython(デフォ) > PyPy(書き換え不要) > Numba(関数の前に@jitを書くだけ) > Codon(型ヒントを追加) > Cython(独特の型宣言や関数定義) > 超えられない壁 > C++(別言語)`
といったような状況のようです。


https://qiita.com/chromia/items/f2facd0637426b4d06c4

https://agency-star.co.jp/corporate/column/pypy/


## 3-1. 処理系

### PyPy

CPythonを制限したRPythonで実装されたPython処理系で、かつJITコンパイルをするものらしいです。
競プロでよく使われるみたいですが、`PyPy`について説明したwebサイトが少ないです。


https://www.sejuku.net/blog/90319

https://qiita.com/y-oksaku/items/f0c5c4681bc30dddf7f4#%E3%81%BE%E3%81%A8%E3%82%81


## 3-2. コンパイラ

### Numba

比較的簡単に高速化できる方法が、`Numba`ライブラリを使用することです。
コードを最適化して事前にコンパイルすることで、数十倍速くなることもあるそうです。
コードをほぼ書き換えずに（正確には、インポートして関数の前にデコレータを付け足すなどして）高速化することができます。

https://qiita.com/gyu-don/items/9d223b007ca620e95abc

https://qiita.com/sonokr/items/4b35ac2137bb16e82bd0

https://qiita.com/nabenabe0928/items/a02964d8b48619b1e348

https://qiita.com/tariaki/items/83a9115d672fe9c3becb

https://numba.pydata.org/numba-doc/latest/user/jit.html#basic-usage

http://numba.pydata.org/numba-doc/0.15.1/quickstart.html




### Cython

Pythonが遅いならPythonのコードをcに変換してコンパイルしまおうという発想。
C言語になるので、とても高速（ちゃんと書けば100倍）になりますが、Pythonコード内で型宣言をする必要があるみたいです。
`Numba`と比べて、C言語の動作環境を作ったりと導入までがめんどくさそうです。

https://qiita.com/pashango2/items/45cb85390193d97523ca

https://www.sejuku.net/blog/60454

https://hack.nikkei.com/blog/advent20211225/






### Codon

ほぼPythonのコードで、コンパイル時にネイティブなマシンコードにすることで高速化を実現した新しいコンパイラです。
新しいのでまだ情報が全然ありません。

https://zenn.dev/turing_motors/articles/e23973714c3ecf




































# 4. Pythonライブラリレベル

Pythonプログラム内で使用することで高速化につながるライブラリを紹介します。


### NumPy

C言語とFortranで書かれた、高速に配列（行列）の計算をするライブラリです。
非常に有名で、しょっちゅう出てきます。
ただし、numpy.arrayをforループで回すと遅くなるなどの落とし穴があるみたいなので注意しましょう。

https://qiita.com/jabberwocky0139/items/c3620fb2f011f20a633b

https://qiita.com/jabberwocky0139/items/57637c1368ea1ebc9b45

https://sucrose.hatenablog.com/entry/2012/12/25/174118

https://qiita.com/tobimogura/items/c1b0daedd641aa466b61


#### 20220914追記
numpyは裏でBLASを呼び出しているらしいですが、このBLASの種類によって計算速度が異なるそうです。
最速はintel製の`Intel MKL`で、`conda`で`numpy`をインストールするとこれが入っていますが、`pip`でインストールすると`OpenBLAS`が使用され、遅くなってしまうそうです。
どちらのBLASが入っているかは以下のようにして確認できます。

```python
import numpy as np
np.__config__.show()
```

https://insilico-notebook.com/python-blas-performance/



### pickle
データの読み込む際に、`pickle`を使用すると速くなります。
`pickle`はPythonオブジェクトをバイナリファイルにする`Pickle 化`をするライブラリで、Python以外では読み込めませんが、とても高速に（十数倍）読み込むことができるというメリットがあります。


https://techacademy.jp/magazine/15826

https://hyper-pigeon.hatenablog.com/entry/2021/08/04/225814















# 5. コーディングレベル

Pythonのプログラムの書き方次第で高速化できる方法はたくさんあります。
この章では、Pythonの理解、アルゴリズム、メモリの理解についてまとめます。





## 5-1. Pythonの理解
Python特有の高速化方法があります。
例えば、`内包表記`や、importの方法についてです。

https://qiita.com/y__sama/items/a2c458de97c4aa5a98e7

https://www.medi-08-data-06.work/entry/speedup_python



## 5-2. アルゴリズム
アルゴリズムは、Pythonだけでなく、すべてのプログラムに通用する基本的な考え方です。
アルゴリズムの速度の指標として、$O(n^2)$ や $O(n\log{n})$ や $O(2^n)$ といった**計算量オーダー**を使用します。
アルゴリズムには、探索、ソート、最適化などさまざまな種類があり、それぞれにさまざまなアルゴリズムが存在しますが、紹介しきれないのでまとめて紹介します。



https://qiita.com/drken/items/872ebc3a2b5caaa4a0d0


https://qiita.com/H20/items/1a066e242815961cd043

https://qiita.com/square1001/items/6d414167ca95c97bd8b2

https://qiita.com/e869120/items/25cb52ba47be0fd418d6

https://qiita.com/e869120/items/b4a0493aac567c6a7240#3-4-%E5%86%8D%E5%B8%B0%E9%96%A2%E6%95%B0%E3%81%AB%E5%AD%A6%E3%81%B6%E6%95%B0%E5%88%97%E3%81%AE%E6%BC%B8%E5%8C%96%E5%BC%8F%E3%83%AC%E3%83%99%E3%83%ABstar3

https://qiita.com/omiita/items/1735c1d048fe5f611f80

世界的なアルゴリズムのバイブル　[The Art of Computer Programming（Amazon）](https://www.amazon.co.jp/Computer-Programming-Volume1-Fundamental-Algorithms/dp/475614411X)





## 5-3. メモリの理解
プログラムが配列をメモリに格納する方法は、`Row-major order方式`と`Column-major order方式`があります。
Python(numpy)は`Row-major order方式`なので、2次元なら(A[0][0], A[0][1], A[0][2], A[1][0], ...という順に、3次元なら[k,j,i]順にアクセスすると速いそうです。


### 高速化について

[座学「並列プログラミング入門」in 金沢 第1講　プログラム高速化の基礎PDF](https://www.cc.u-tokyo.ac.jp/events/lectures/X01/shiryou-1.pdf)


https://qiita.com/tyoshitake/items/83ce47f169c5b037f06c


### メモリ格納について

[名古屋大学情報基盤センター　MPIの基礎](https://www.r-ccs.riken.jp/wp/wp-content/uploads/2020/09/katagiri190411.pdf)

https://daeudaeu.com/array_access/

https://qiita.com/Nanarlium/items/5fcdd0adeeb13ccc8524

https://qiita.com/wm-ytakano/items/c8341f8326d1cc0fa4ee

[高性能プログラミング（Ⅰ）入門編](https://www.cc.u-tokyo.ac.jp/public/VOL10/No4/200807tuning.pdf)







































# 6. 番外編：高速な他言語のプログラムを呼び出す

ここまで基本的にPythonについての高速化の方法をまとめてきました。
この章では、「Pythonが遅い言語なら、他のの高速な言語で書いたプログラムを呼び出して使えばいいじゃん」という発想のもと、その方法をまとめます。
今回は、有名な高速な言語として、`Fortran`, `C`, `C++`, `julia`についてまとめました。

## 6-1. Fortran

`ctypes`を使用する方法と、`f2py`を使用する方法がある。

https://qiita.com/nqomorita/items/616e85bd77918a7e87b9

https://mnakao.net/data/2018/HPFPC.pdf

https://rikei-fufu.com/2019/12/30/post-2525-py-call-for/

## 6-2. C

どうやらCでラッパーを作る方法と、`ctypes`ライブラリを使うの二種類があるらしい
ちょっと私の理解不足で、うまく説明できませんでした。

https://www.fsi-embedded.jp/kumico/column/179/

### ラッパー

https://qiita.com/nabion/items/594fb3316583130a636e

https://tanakatarou.tech/261/

https://www.fsi-embedded.jp/kumico/column/1543/

https://www.fsi-embedded.jp/kumico/column/1996/

### ctypes

https://it-ojisan.tokyo/python-call-clib/

https://qiita.com/everylittle/items/6e18ba23f38502c18f3e#ctypes%E3%81%A8%E3%81%AF


## 6-3. C++
どうやら`pybind11`ライブラリを使う方法と、`swig`を使う方法があるらしい。

https://zenn.dev/t_ibe/articles/400aa60a12434d

https://www.letsopt.com/entry/2020/08/07/014629

https://www.fsi-embedded.jp/kumico/column/1996/#:~:text=SWIG%E3%81%AF%E3%80%8CSimplified%20Wrapper%20Interface,%E3%82%A4%E3%83%B3%E3%82%B9%E3%83%88%E3%83%BC%E3%83%AB%E3%81%99%E3%82%8B%E5%BF%85%E8%A6%81%E3%81%8C%E3%81%82%E3%82%8A%E3%81%BE%E3%81%99%E3%80%82

## 6-4. julia

https://qiita.com/cometscome_phys/items/31d0b811345a3e12fcef

https://qiita.com/SatoshiTerasaki/items/9d775c294a10c1f2edfe





















# 7. ハードウェアの選択

プログラムを実行しているのはコンピュータです。
ならば、スペックの高いコンピュータを使用すれば実行速度は速くなります。
といっても、相当なこと（ものすごいボトルネックの解消など）がない限り数倍の高速化などにはならないと思います。
__スペックの高いコンピュータ__ についてまとめていきます。


## PCパーツ全体

https://kakaku.com/pc/article/homebuilt-pc-parts/

https://tomoyuki65.com/summary-of-recommended-parts-for-homebrew-pc/

https://qiita.com/yuki_2020/items/c233d903fe41d98bfff3




## OS
正確にはソフトウェアですが、パソコンを買うときに決まるようなものなのでここで紹介します。
有名なOSといえばwindowsとlinuxでしょう。
機械学習はlinuxのほうがwindowよりも倍ぐらい速いみたいです。
他の普通のプログラムはlinuxのほうがwindowよりもほんのちょっと速いみたいですが、大した差がないみたいです。

https://tech.morikatron.ai/entry/2020/03/20/100000







## CPU
CPUで重要になってくる要素は動作周波数、コア数（並列数）、キャッシュの3つです。

動作周波数は高ければ高いほど1秒間に演算できる回数が増え、プログラムの実行速度向上が見込めます。さらに、CPIと言って一命令数当たりにかかるクロック数の数も世代がたつにつれて向上しているようですが、正直プログラムが早くなるかは内容によるのでなんとも言えなさそうです。

コア数は並列処理をする場合、効いてきます
これはプログラムが並列処理に対応しているか、並列処理が効きやすいプログラム化で変わってきます。

キャッシュは、メモリからデータをとってくる代わりにCPUに近いキャッシュにデータを置いておくというものであり、AMDがRyzen5800X3Dなどのようにゲーム向けにキャッシュを増やしたCPUを販売していますが、プログラムで改善が望めるかはわかりません。

いろいろ書きましたが、基本的に**世代が新しくて動作周波数が高いもの**を買えばよさそうです。
ただし並列化するならコア数、スレッド数が多いものを買うといいです。

https://kakaku.com/pc/cpu/guide_0510/

https://pikawaka.com/word/cpu

https://www.amazon.co.jp/%E3%82%B3%E3%83%B3%E3%83%94%E3%83%A5%E3%83%BC%E3%82%BF%E3%81%AE%E6%A7%8B%E6%88%90%E3%81%A8%E8%A8%AD%E8%A8%88-%E7%AC%AC5%E7%89%88-%E4%B8%8A-%E3%82%B8%E3%83%A7%E3%83%B3%E3%83%BBL-%E3%83%98%E3%83%8D%E3%82%B7%E3%83%BC/dp/4822298426



## GPU
GPGPUや、ディープラーニングをするなら一番重要です。
GPUで重要になってくることは、演算性能とメモリ、ディープラーニング用のコアがあるかなどでしょう。

演算性能は、1秒間に浮動小数点演算が何回できるかという指標であり、コアの数が大きいほど大きくなる傾向があり、基本的にはGPUの性能はこれで測ります。

メモリについて、特に近年のディープラーニングではモデルのサイズがどんどん大きくなっており、メモリの大きさ次第で実行できるプログラムも変わってくるため重要になってきています。

ディープラーニング専用のコアを搭載するGPUも出てきており、NvidiaならRTコア、AppleならNeural Engineなどがあります。


https://www.pc-koubou.jp/magazine/34308

https://note.com/sakulab/n/n6717010697ae

https://tabulog.org/graphicboard-how-to-select/#spec

https://www.nvidia.com/ja-jp/data-center/tensor-cores/

## メモリ
プログラム実行時にメモリをたくさん使うなら、メモリ容量を十分確保する必要があります。
また、動作周波数や転送速度なども種類がありますが、詳しくは触れません。

https://kakaku.com/pc/pc-memory/guide_0520/

https://chimolog.co/bto-best-ddr4-ram/

https://chimolog.co/bto-ram-clock-speed/


## ストレージ（HDD、SSD）
保存したデータの読み出し、データの書き込みに時間がかかっているなら、SSDの中でも高速なものにすることで高速化が見込めます。
SSDといってもさらに普通のSATA接続のものから高速なNVMeSSD、さらにNVMeSSDの中でもgen4、gen5など世代があります。

https://www.ask-corp.jp/guide/pc-parts-storage.html














# 最後に
Pythonの実行を高速化する方法をまとめました。
思った以上に様々な方法があり、また規模も全然違うため、分類してまとめるのが大変でした。
しかし書き終わってみると、かなり高速化について浅く広い知識が付きました。
それぞれのプログラムにあった高速化方法があると思うので、ぜひ逆引きとして使用してください。

また、何か間違い、他の高速化方法などありましたら、遠慮なくコメントしてください。
よろしくお願いします。















# その他参考になったサイト

https://codezine.jp/article/detail/8687

https://qiita.com/sotasato/items/cc36a532ba6487dd3dba

https://qiita.com/yoskeoka/items/15f192f791201c5ac6d7

https://qiita.com/zettaittenani/items/3bb25752d6e6a458332e

https://www.cc.u-tokyo.ac.jp/events/lectures/X01/

https://www.cc.u-tokyo.ac.jp/events/lectures/materials/

https://qiita.com/ShigemoriMasato/items/7081c88482e27b7f8535