├── LICENSE.md
├── README.md
├── cover_image.png
├── error_table.txt
└── src
    ├── chapter1
        ├── c_bench1.c
        ├── filelist.txt
        └── py_bench1.py
    ├── chapter10
        ├── filelist.txt
        └── pd_plt1.py
    ├── chapter11
        ├── filelist.txt
        ├── for_listcomp.py
        ├── spd_multip2.py
        ├── spd_profile.py
        └── spd_profile2.py
    ├── chapter12
        ├── cython_1.pyx
        ├── cython_2.pyx
        ├── cython_3.py
        ├── filelist.txt
        ├── myfunc_cdecl.c
        ├── myfunc_stdcall.c
        ├── py_c_api.c
        ├── setup_cy1.py
        ├── setup_cy2.py
        ├── spc_numba1.py
        ├── spd_numba2.py
        ├── spd_numba4.py
        └── spd_numexpr.py
    ├── chapter2
        └── Readme.txt
    ├── chapter3
        ├── fc.py
        ├── filelist.txt
        ├── myscript.py
        ├── prun1.py
        └── prun2.py
    ├── chapter4
        ├── decorator_1.py
        ├── filelist.txt
        ├── module_1.py
        └── module_2.py
    ├── chapter5
        ├── class1.py
        ├── class2.py
        ├── class3.py
        ├── classmethod1.py
        ├── filelist.txt
        ├── inheritance1.py
        ├── instance1.py
        ├── scope_error.py
        └── static1.py
    ├── chapter6
        ├── csv_read1.py
        ├── csv_read2.py
        ├── data1.csv
        ├── excel_read1.py
        ├── filelist.txt
        ├── hdf5-1.py
        ├── matread1.py
        ├── npynpz1.py
        ├── openpyxl1.py
        ├── pickle1.py
        ├── pickle2.py
        └── pickle3.py
    ├── chapter7
        └── filelist.txt
    ├── chapter8
        ├── filelist.txt
        ├── plt_bode.py
        ├── plt_fft.py
        ├── plt_iir.py
        ├── plt_interp.py
        └── plt_rayleigh.py
    └── chapter9
        ├── filelist.txt
        ├── plt_3d.py
        ├── plt_contour.py
        ├── plt_gridspec.py
        ├── plt_in_plt.py
        ├── simple_2d.py
        └── subplot_2x3.py


/LICENSE.md:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pyjbooks/py4science/0cf524c47c19c5d36763e5b7501107e0ecff8c54/LICENSE.md


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # 「科学技術計算のためのPython入門――開発基礎、必須ライブラリ、高速化」
 2 | 
 3 | 本レポジトリは、技術評論社から出版された以下の書籍
 4 | のWeb補足情報を提供するためのものです。
 5 | 
 6 | <img src="cover_image.png" align="center" width="300" >
 7 | 
 8 | タイトル: 科学技術計算のためのPython入門――開発基礎、必須ライブラリ、高速化  
 9 | 著者: 中久喜 健司（なかくき けんじ）  
10 | 単行本（ソフトカバー）: 416ページ  
11 | 出版社: 技術評論社  
12 | 言語: 日本語  
13 | ISBN-10: 4774183881  
14 | ISBN-13: 978-4774183886  
15 | 発売日: 2016/9/24  
16 | 技術評論社のサポートページ: http://gihyo.jp/book/2016/978-4-7741-8388-6/  
17 | 
18 | 本レポジトリでは、主に書籍中のソースコードを提供するとともに、Webサポートページに
19 | 上記の書籍をサポートする情報を提供します。
20 | 
21 | GitHubレポジトリ: https://github.com/pyjbooks/py4science  
22 | 同サポートページ: https://pyjbooks.github.io/py4science/
23 | 
24 | 
25 | # ソースコードについて
26 | 
27 | ## ファイルの所在
28 | 
29 | 本レポジトリのmasterブランチの「src」フォルダ以下に、書籍の章ごとに分けて格納してあります。Gitを使える方は、クローンして入手してください。Gitを使えない方は、本GitHubレポジトリのトップページで、[Clone or download]というボタンを押して、zipファイルとしてダウンロードしてください。
30 | 
31 | ## 「改行」と「空白」
32 | 書籍の中では、紙幅の都合上、*「改行」や「空白」をわざと減らしている*部分がありますが、本レポジトリに含まれるソースコードは、PEP 8に準拠できるように改行や空白を挿入しています。
33 | 
34 | ## import文の省略
35 | また、ソースコードの冒頭に含まれるimport文についても、紙幅の都合上、書籍の中では*省略している場合があります*。以下のimport文が先頭に付いていることを前提としていますので、ご注意ください。本レポジトリに含まれるソースコードでは、省略せずに記載しています。
36 | 
37 |     import numpy as np  # NumPyの別名はnp
38 |     import scipy as sp  # SciPyの別名はsp
39 |     import pandas as pd  # pandasの別名はpd
40 |     import matplotlib as mpl  # Matplotlibの別名はmpl
41 |     import matplotlib.pyplot as plt  # Matplotlib.pyplotの別名はplt
42 |     import numexpr as ne  # Numexprの別名はne
43 | 
44 | ## Matplotlibの設定
45 | 
46 | Matplotlibの設定がユーザの環境によって異なることで、本書の中で示したプロット結果と、多少「体裁」が異なる結果が得られる場合があります。その場合には、本書の9.2項を参考に、設定をご自分で調整してみてください。
47 | 
48 | 特に、本書では以下の設定を推奨しており、本書に示した図と異なる場合には以下の設定を加えてみてください。（「mpl」は上記のとおり、「matplotlib」の別名）
49 | 
50 |     mpl.rcParams['figure.autolayout'] = True
51 |     mpl.rcParams['font.size'] = 14
52 |     mpl.rcParams['axes.grid'] = True
53 | 
54 | また、インタラクティブモードがoffになっている場合は、プロットした図が表れない場合があります。
55 | その場合は、`plt.ion()`（「plt」は上記のとおり「matplotlib.pyplot」の別名）として、インタラクティブモードをonにしてください。
56 | もしくは、プロットの最後に、`plt.show()`を追加することで、図を表示させることができます。
57 | 
58 | ## その他
59 | 
60 | 稀に間違いが見つかった場合などに、本レポジトリのソースコードにおいては修正が加えられている場合があります。その他にも、書籍の中のソースコードに、上記のとおりimport文が加えられている場合や、軽微な修正が行われている場合があります。
61 | 
62 | # 正誤表
63 | 
64 | 本レポジトリの「error_table.txt」に、本書中の誤記等の訂正を示してあります。
65 | 
66 | # ライセンス
67 | 
68 | 本レポジトリのソースコードについては、「LICENSE.md」に示したとおりです。
69 | 
70 | 


--------------------------------------------------------------------------------
/cover_image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/pyjbooks/py4science/0cf524c47c19c5d36763e5b7501107e0ecff8c54/cover_image.png


--------------------------------------------------------------------------------
/error_table.txt:
--------------------------------------------------------------------------------
 1 | p.178 (前頁から続く「リスト5.3」の最終行のコメント)
 2 | 誤）# 結果は 3*5*5=45（追加したメソッドの確認）
 3 | 正）# 結果は 3*3*5=45（追加したメソッドの確認）
 4 | 
 5 | 
 6 | ※以下の全ての誤記は、第4刷以降修正済み
 7 | 
 8 | p. 71
 9 | 誤）そして、その実行文の返り値（計算結果）はOut[3]:の後ろに表示されています。
10 | 正）そして、その実行文の返り値（計算結果）はOut[4]:の後ろに表示されています。
11 | 
12 | p. 195 (上から6行目)
13 | 誤）laodtxtとgenfromtxtを利用...
14 | 正）loadtxtとgenfromtxtを利用...
15 | 
16 | p. 196
17 | 誤）OOXML形式（Office Open XML、拡張子.xlsx/.xlsm）：openpyxl、xlwings
18 | 正）OOXML形式（Office Open XML、拡張子.xlsx/.xlsm）：xlrd、openpyxl、xlwings
19 | （注：xlrdのVersion 0.8.0以降では、OOXML形式にも対応しており上記のとおり訂正しますが、
20 |       まだまだ機能的には発展途上と考えておいた方が良いでしょう。）
21 | 
22 | p. 222 (IPythonのコード例のうち、In [3]: の行)
23 | 誤）# 16 bit符号なし整数型のndarray
24 | 正）# 64 bitの浮動小数点で構成される複素数
25 | 
26 | p.294 
27 | 誤---ここから
28 | In [10]: dat8.index = ['un', 'due', 'trois', 'quatre']
29 | Out[10]: dat8
30 | un 1
31 | due 3
32 | trois NaN
33 | quatre 12
34 | dtype: float64
35 | 誤---ここまで
36 | 正---ここから
37 | In [10]: dat7.index = ['un', 'due', 'trois', 'quatre']
38 | Out[10]: dat7
39 | un         1
40 | due        3
41 | trois      6
42 | quatre    12
43 | dtype: int64
44 | 正---ここまで
45 | 
46 | 
47 | ※以下の4つの誤記は、第2刷以降修正済み
48 | 
49 | p. 199とp.200のソースコード中(各ページ１か所)
50 | 誤）# 保存ｌするオブジェクトの準備
51 | 正）# 保存するオブジェクトの準備
52 | 
53 | p.363
54 | 誤）In [14]: %run numba_jit.py
55 | 正）In [14]: %run spd_numba1.py
56 | 
57 | p.366
58 | 誤）In [15]: %run numba_classjit.py # @jitclassデコレータが無効な場合
59 | 正）In [15]: %run spd_numba2.py # @jitclassデコレータが無効な場合
60 | 
61 | p.366
62 | 誤）In [16]: %run numba_classjit.py # @jitclassデコレータが有効な場合
63 | 正）In [16]: %run spd_numba2.py # @jitclassデコレータが有効な場合
64 | 
65 | 


--------------------------------------------------------------------------------
/src/chapter1/c_bench1.c:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <windows.h>
 3 | #include <stdlib.h>
 4 | 
 5 | const int N = 10000;
 6 | const int M = 1000;
 7 | const int L = 10000;
 8 | 
 9 | int main(int argc, char** argv)
10 | {
11 |     int i, j, k;
12 |     double a[M], S[N][L], x[N][M], y[M][L];
13 |     LARGE_INTEGER start_pc, end_pc, freq_pc;
14 | 
15 |     /* ① 配列に値を設定 */
16 |     srand(1);
17 |     double rnd_max = (double) RAND_MAX;
18 |     for (i=0; i<M; i++) {
19 |         a[i] = (rnd_max*0.5 - rand()) / rnd_max;
20 |     }
21 |     for (i=0; i<N; i++) {
22 |         for (j=0; j<M; j++) {
23 |             x[i][j] = (rnd_max*0.5 - rand()) / rnd_max;
24 |         }
25 |     }
26 |     for (i=0; i<M; i++) {
27 |         for (j=0; j<L; j++) {
28 |             y[i][j] = (rnd_max*0.5 - rand()) / rnd_max;
29 |         }
30 |     }
31 |     for (i=0; i<N; i++) {
32 |         for (j=0; j<L; j++) {
33 |             S[i][j] = 0.0;
34 |         }
35 |     }
36 |     
37 |     /* ② 処理開始時の時間を計測 */
38 |     QueryPerformanceFrequency( &freq_pc );
39 |     QueryPerformanceCounter( &start_pc );
40 | 
41 |     /* ③ 行列演算処理(処理時間計測対象) 式(1-1)の処理 */
42 |     for (i=0; i<N; i++) {
43 |         for (j=0; j<L; j++) {
44 |             for (k=0; k<M; k++) {
45 |                 S[i][j] += a[k]*x[i][k]*y[k][j];
46 |             }
47 |         }
48 |     }
49 |     
50 |     /* ④ 処理終了時の時間を計測*/
51 |     QueryPerformanceCounter( &end_pc );
52 |     double sec_pc = (end_pc.QuadPart - start_pc.QuadPart) / (double)freq_pc.QuadPart;
53 |     printf("計算時間 = %.3lf[ms]\n", sec_pc * 1000);
54 | 
55 |     /* ⑤ 最適化によりSの計算が省略されないように、計算後にランダム参照 */
56 |     i = (int) (start_pc.QuadPart % N);
57 |     j = (int) (end_pc.QuadPart % L);
58 |     printf("S[%d][%d] = %.3lf\n", i, j, S[i][j]);
59 | 
60 |     return 0;
61 | }
62 | 
63 | 


--------------------------------------------------------------------------------
/src/chapter1/filelist.txt:
--------------------------------------------------------------------------------
1 | p.23  : c_bench1.c
2 | p.25  : py_bench1.py
3 | 


--------------------------------------------------------------------------------
/src/chapter1/py_bench1.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import time
 3 | 
 4 | 
 5 | def mult_basic(N, M, L, a, x, y):
 6 |     """ 行列計算は使わずにForループで計算する関数
 7 |         ただし、所望のサイズの非ndarrayを作成するのが困難なので、
 8 |         入力の変数はNumPyのndarrayとして生成して渡す """
 9 |     r = np.empty((N, L))
10 |     for i in range(N):
11 |         for j in range(L):
12 |             tmp = 0.0
13 |             for k in range(M):
14 |                 tmp = tmp + a[k]*x[i][k]*y[k][j]
15 |             r[i][j] = tmp
16 |     return r
17 | 
18 | 
19 | def mult_fast(N, M, L, a, x, y):
20 |     """ NumPyの関数を使って高速に計算する関数
21 |         関数mult_basicと全く同じ結果を得る"""
22 |     return np.dot(x*a, y)  # 処理の記述はたったの1行
23 | 
24 | 
25 | if __name__ == '__main__':
26 |     # 計算に使う配列の生成
27 |     np.random.seed(0)
28 |     N = 10000
29 |     M = 1000
30 |     L = 10000
31 |     a = np.random.random(M) - 0.5
32 |     x = np.random.random((N, M)) - 0.5
33 |     y = np.random.random((M, L)) - 0.5
34 | 
35 |     # 行列計算は使わずにForループで計算
36 |     ts = time.time()
37 |     r1 = mult_basic(N, M, L, a, x, y)
38 |     te = time.time()
39 |     print("Basic method : %.3f [ms]" % (1000*(te - ts)))
40 | 
41 |     # NumPyの関数を使って高速に処理
42 |     ts = time.time()
43 |     r2 = mult_fast(N, M, L, a, x, y)
44 |     te = time.time()
45 |     print("Fast method  : %.3f [ms]" % (1000*(te - ts)))
46 | 


--------------------------------------------------------------------------------
/src/chapter10/filelist.txt:
--------------------------------------------------------------------------------
1 | p.319  : pd_plt1.py
2 | 


--------------------------------------------------------------------------------
/src/chapter10/pd_plt1.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import pandas as pd
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | plt.style.use('ggplot')
 6 | 
 7 | # %% line plot
 8 | df = pd.DataFrame(np.random.randn(500, 3), columns=list('XYZ'),
 9 |                   index=pd.date_range('1/1/2016', periods=500))
10 | 
11 | df = df.cumsum()
12 | ax = df.plot(colormap='gray', fontsize=14)
13 | ax.set_ylabel('Value', fontsize=14)
14 | 
15 | # %% bar plot
16 | df2 = pd.DataFrame(np.random.rand(5, 3),
17 |                    columns=['a', 'b', 'c'])
18 | 
19 | df2.plot(kind='bar', stacked=True, colormap='gray', fontsize=14)
20 | 


--------------------------------------------------------------------------------
/src/chapter11/filelist.txt:
--------------------------------------------------------------------------------
1 | p.327  : for_listcomp.py
2 | p.333  : spd_profile.py
3 | p.335  : spd_profile2.py (spd_profile.pyの例の「if __name__ == '__main__':
4 | 以下」を書き換えたもの。line_profiler利用の例。)
5 | p.346  : spd_multip2.py
6 | 
7 | 


--------------------------------------------------------------------------------
/src/chapter11/for_listcomp.py:
--------------------------------------------------------------------------------
 1 | def list_by_for(x, y):
 2 |     z = []
 3 |     append = z.append
 4 |     for k in range(len(x)):
 5 |         append(x[k]*y[k] + 0.1*y[k])
 6 |     return z
 7 | 
 8 | def list_by_lc(x, y):
 9 |     return [a*b + 0.1*b for a, b in zip(x, y)]
10 | 
11 | if __name__ == '__main__':
12 |     N1 = 1000000
13 |     x = list(range(N1, 0, -1))
14 |     y = list(range(N1))
15 |     z1 = list_by_for(x, y)  # 実際はこの処理の時間を計測する
16 |     z2 = list_by_lc(x, y)  # 実際はこの処理の時間を計測する
17 | 


--------------------------------------------------------------------------------
/src/chapter11/spd_multip2.py:
--------------------------------------------------------------------------------
 1 | import concurrent.futures
 2 | import math
 3 | import time
 4 | 
 5 | PRIMES = [
 6 |     112272535095293,
 7 |     112582705942171,
 8 |     112272535095293,
 9 |     115280095190773,
10 |     115797848077099,
11 |     1099726899285419]
12 | 
13 | 
14 | def is_prime(n):
15 |     if n % 2 == 0:
16 |         return False
17 | 
18 |     sqrt_n = int(math.floor(math.sqrt(n)))
19 |     for i in range(3, sqrt_n + 1, 2):
20 |         if n % i == 0:
21 |             return False
22 |     return True
23 | 
24 | 
25 | def main1():
26 |     """ マルチプロセス処理で素数判定 """
27 |     ts = time.clock()
28 |     with concurrent.futures.ProcessPoolExecutor() as executor:
29 |         ans = list(executor.map(is_prime, PRIMES))
30 |     print('マルチプロセス処理の時間: {0:.3f}[s])'.format(time.clock() - ts))
31 |     print(ans)
32 | 
33 | 
34 | def main2():
35 |     """ シングルプロセス処理で素数判定 """
36 |     ts = time.clock()
37 |     ans = list(map(is_prime, PRIMES))  # python 3ではlist化により計算が実行される
38 |     print('シングルプロセス処理の時間: {0:.3f}[s])'.format(time.clock() - ts))
39 |     print(ans)
40 | 
41 | 
42 | if __name__ == '__main__':
43 |     main1()
44 |     main2()
45 | 


--------------------------------------------------------------------------------
/src/chapter11/spd_profile.py:
--------------------------------------------------------------------------------
 1 | import cProfile
 2 | import numpy as np
 3 | import pstats
 4 | 
 5 | 
 6 | def is_prime(a):
 7 |     """ 素数判定プログラム（フェルマーの小定理） """
 8 |     a = abs(a)
 9 |     if a == 2:
10 |         return True
11 |     if a < 2 or a & 1 == 0:
12 |         return False
13 |     return pow(2, a-1, a) == 1
14 | 
15 | 
16 | def mysum(n):
17 |     """ 1からNまでの整数の和を計算する """
18 |     return np.arange(1, n+1).sum()
19 | 
20 | 
21 | def task1(n):
22 |     """ 次の２つの処理を行う
23 |        (1) 1からNまでの整数の中から素数を探す
24 |        (2) 1からNまでの整数の和を計算する
25 |     """
26 |     # (1)
27 |     out = []
28 |     append = out.append
29 |     for k in range(1, n+1):
30 |         if is_prime(k):
31 |             append(k)
32 |     # (2)
33 |     a = mysum(n)
34 |     return [out, a]
35 | 
36 | 
37 | def task2(n):
38 |     """ 1からNまでのsqrt()を計算する """
39 |     return np.sqrt(np.arange(1, n+1))
40 | 
41 | 
42 | def main():
43 |     task1(100000)  # 重い処理
44 |     task2(100000)  # 軽い処理
45 | 
46 | 
47 | if __name__ == '__main__':  # (3)
48 |     cProfile.run('main()', filename='main.prof')
49 |     sts = pstats.Stats('main.prof')
50 |     sts.strip_dirs().sort_stats('cumulative').print_stats()
51 | 


--------------------------------------------------------------------------------
/src/chapter11/spd_profile2.py:
--------------------------------------------------------------------------------
 1 | import cProfile
 2 | import numpy as np
 3 | import pstats
 4 | 
 5 | 
 6 | def is_prime(a):
 7 |     """ 素数判定プログラム（フェルマーの小定理） """
 8 |     a = abs(a)
 9 |     if a == 2:
10 |         return True
11 |     if a < 2 or a & 1 == 0:
12 |         return False
13 |     return pow(2, a-1, a) == 1
14 | 
15 | 
16 | def mysum(n):
17 |     """ 1からNまでの整数の和を計算する """
18 |     return np.arange(1, n+1).sum()
19 | 
20 | 
21 | def task1(n):
22 |     """ 次の２つの処理を行う
23 |        (1) 1からNまでの整数の中から素数を探す
24 |        (2) 1からNまでの整数の和を計算する
25 |     """
26 |     # (1)
27 |     out = []
28 |     append = out.append
29 |     for k in range(1, n+1):
30 |         if is_prime(k):
31 |             append(k)
32 |     # (2)
33 |     a = mysum(n)
34 |     return [out, a]
35 | 
36 | 
37 | def task2(n):
38 |     """ 1からNまでのsqrt()を計算する """
39 |     return np.sqrt(np.arange(1, n+1))
40 | 
41 | 
42 | def main():
43 |     task1(100000)  # 重い処理
44 |     task2(100000)  # 軽い処理
45 | 
46 | 
47 | if __name__ == '__main__':  # (3)
48 |     from line_profiler import LineProfiler
49 |     prf = LineProfiler()
50 |     prf.add_function(is_prime)
51 |     prf.runcall(is_prime, 999)
52 |     prf.print_stats()
53 | 


--------------------------------------------------------------------------------
/src/chapter12/cython_1.pyx:
--------------------------------------------------------------------------------
 1 | def primes(int kmax):
 2 |     cdef int n, k, i
 3 |     cdef int p[1000]
 4 |     result = []
 5 |     if kmax > 1000:
 6 |         kmax = 1000
 7 |     k = 0
 8 |     n = 2
 9 |     while k < kmax:
10 |         i = 0
11 |         while i < k and n % p[i] != 0:
12 |             i = i + 1
13 |         if i == k:
14 |             p[k] = n
15 |             k = k + 1
16 |             result.append(n)
17 |         n = n + 1
18 |     return result
19 | 


--------------------------------------------------------------------------------
/src/chapter12/cython_2.pyx:
--------------------------------------------------------------------------------
 1 | """ NumPyのndarrayを使う関数のCythonプログラム例 """
 2 | 
 3 | cimport numpy as np
 4 | from cython.parallel import prange
 5 | 
 6 | N = 10000000
 7 | 
 8 | def matrix_cal_cy(np.ndarray[double, ndim=1] X,
 9 |                   np.ndarray[double, ndim=1] Y, double a):
10 |     cdef int i
11 |     for i in prange(N, nogil=True):
12 |         if Y[i] < 0:
13 |             Y[i] += 10.0 +  1e-7*i
14 |     return (a*X + np.exp(Y))
15 | 


--------------------------------------------------------------------------------
/src/chapter12/cython_3.py:
--------------------------------------------------------------------------------
 1 | import cython_2
 2 | import numpy as np
 3 | import time
 4 | 
 5 | N = 10000000
 6 | 
 7 | 
 8 | # cython_2.pyの関数のPythonオリジナル
 9 | def matrix_cal(X, Y, a):
10 |     for i in range(N):
11 |         if Y[i] < 0:
12 |             Y[i] += 10.0 + 1e-7*i
13 |     return a*X + np.exp(Y)
14 | 
15 | if __name__ == '__main__':
16 |     # 計算に使うndarrayを生成
17 |     a = 3.4
18 |     X = np.random.randn(N)
19 |     Y = np.random.randn(N)
20 |     # Cython版で計算
21 |     ts = time.clock()
22 |     Z = cython_2.matrix_cal_cy(X, Y, a)
23 |     print('Cython版の処理の時間: {0:.3f}[s]'.format(time.clock() - ts))
24 |     # オリジナルのmatrix_calで計算
25 |     ts = time.clock()
26 |     Z = matrix_cal(X, Y, a)
27 |     print('オリジナル版の処理の時間: {0:.3f}[s]'.format(time.clock() - ts))
28 | 


--------------------------------------------------------------------------------
/src/chapter12/filelist.txt:
--------------------------------------------------------------------------------
 1 | p.352  : cython_1.pyx
 2 | p.353  : setup_cy1.py
 3 | p.354  : cython_2.pyx
 4 | p.355  : setup_cy2.py
 5 | p.356  : cython_3.py
 6 | p.358  : py_c_api.c
 7 | p.358  : myfunc_cdelc.c
 8 | p.359  : myfunc_stdcall.c
 9 | p.362  : spd_numba1.py
10 | p.365  : spd_numba2.py
11 | p.367  : spd_numba4.py
12 | p.368  : spd_numexpr.py
13 | 
14 | 


--------------------------------------------------------------------------------
/src/chapter12/myfunc_cdecl.c:
--------------------------------------------------------------------------------
1 | /* myfunc_cdelc.c */
2 | int myadd(int x, int y) {
3 | 	return x + y;
4 | }
5 | 


--------------------------------------------------------------------------------
/src/chapter12/myfunc_stdcall.c:
--------------------------------------------------------------------------------
1 | /* myfunc_stdcall.c */
2 | #define EXPORT __declspec(dllexport) __stdcall
3 | 
4 | EXPORT int myadd(int x, int y) {
5 | 	return x + y;
6 | }
7 | 


--------------------------------------------------------------------------------
/src/chapter12/py_c_api.c:
--------------------------------------------------------------------------------
 1 | #include <Python.h>
 2 | 
 3 | static PyObject *
 4 | fact(PyObject *self, PyObject *args)
 5 | {
 6 |     int n;
 7 |     int i;
 8 |     int ret=1;
 9 | 
10 |     if (!PyArg_ParseTuple(args, "i", &n))
11 |         return NULL;
12 | 
13 |     for (i=n; i>0; i--) ret *= i;
14 |     
15 |     return Py_BuildValue("i", ret);
16 | }
17 | 


--------------------------------------------------------------------------------
/src/chapter12/setup_cy1.py:
--------------------------------------------------------------------------------
1 | from distutils.core import setup
2 | from Cython.Build import cythonize
3 | 
4 | setup(
5 |     ext_modules=cythonize("cython_1.pyx")
6 | )
7 | 


--------------------------------------------------------------------------------
/src/chapter12/setup_cy2.py:
--------------------------------------------------------------------------------
 1 | from distutils.core import setup
 2 | from distutils.extension import Extension
 3 | from Cython.Build import cythonize
 4 | import numpy as np
 5 | 
 6 | extensions = [
 7 |     Extension("cython_2", ["cython_2.c"],
 8 |               include_dirs=[np.get_include()],
 9 |               libraries=['npymath'],
10 |               library_dirs=['C:/Python/Anaconda3/Lib/site-packages/numpy/core/lib'],
11 |               extra_compile_args=['/openmp'],
12 |               extra_link_args=['/openmp']),
13 | ]
14 | 
15 | setup(
16 |     name="My matrix calc",
17 |     ext_modules=cythonize(extensions),
18 |     include_dirs=[np.get_include()]
19 | )
20 | 


--------------------------------------------------------------------------------
/src/chapter12/spc_numba1.py:
--------------------------------------------------------------------------------
 1 | from numba import jit
 2 | import numpy as np
 3 | import time
 4 | 
 5 | 
 6 | def mult_abs_basic(n, x, y):
 7 |     r = []
 8 |     for i in range(n):
 9 |         r.append(abs(x[i] * y[i]))
10 |     return r
11 | 
12 | 
13 | def mult_abs_numpy(x, y):
14 |     return np.abs(x*y)
15 | 
16 | 
17 | # @jitデコレータで高速化を図る
18 | @jit('f8[:](i8, c16[:], c16[:])', nopython=True)
19 | def mult_abs_numba(n, x, y):
20 |     r = np.zeros(n)
21 |     for i in range(n):
22 |         r[i] = abs(x[i] * y[i])
23 |     return r
24 | 
25 | 
26 | if __name__ == "__main__":
27 |     # %% 処理するデータを生成
28 |     N = 1000000
29 |     x_np = (np.random.rand(N) - 0.5) + 1J * (np.random.rand(N) - 0.5)
30 |     y_np = (np.random.rand(N) - 0.5) + 1J * (np.random.rand(N) - 0.5)
31 |     x = list(x_np)
32 |     y = list(y_np)
33 | 
34 |     # %% 処理時間比較
35 |     ts = time.clock()
36 |     b1 = mult_abs_basic(N, x, y)
37 |     print('Pythonの計算時間 : {0:0.3f}[s]'.format(time.clock() - ts))
38 |     ts = time.clock()
39 |     b1 = mult_abs_numpy(x_np, y_np)
40 |     print('NumPyの計算時間 : {0:0.3f}[s]'.format(time.clock() - ts))
41 |     ts = time.clock()
42 |     b1 = mult_abs_numba(N, x_np, y_np)
43 |     print('Numbaの計算時間 : {0:0.3f}[s]'.format(time.clock() - ts))
44 | 


--------------------------------------------------------------------------------
/src/chapter12/spd_numba2.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import time
 3 | from numba import jitclass  # import jitclass decorator
 4 | from numba import int32, float64  # 型名称をimport
 5 | 
 6 | # クラスの属性の型を規定
 7 | spec = [
 8 |     ('size', int32),
 9 |     ('arr', float64[:]),
10 | ]
11 | 
12 | 
13 | @jitclass(spec)
14 | class RandomCode(object):
15 | 
16 |     def __init__(self, size):
17 |         self.size = size
18 |         self.arr = np.random.randn(size)
19 | 
20 |     def bit_code(self):
21 |         for i in range(self.size):
22 |             if self.arr[i] >= 0.5:
23 |                 self.arr[i] = 1
24 |             else:
25 |                 self.arr[i] = -1
26 |         return self.arr
27 | 
28 | 
29 | if __name__ == '__main__':
30 |     a = RandomCode(1000000)
31 |     ts = time.clock()
32 |     cdat = a.bit_code()
33 |     print('コード生成所用時間 : {0:.3f}[s]'.format(time.clock() - ts))
34 | 


--------------------------------------------------------------------------------
/src/chapter12/spd_numba4.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from numba import jit
 3 | 
 4 | nthreads = 2  # 2コアのCPUで検証するのでスレッド数を2にする
 5 | size = 10000000
 6 | 
 7 | 
 8 | # これが高速化する前の関数
 9 | def func_np(a, b):
10 |     return np.exp(2.1 * a + 3.2 * b)
11 | 
12 | 
13 | # Numbaで高速化した関数
14 | @jit('void(double[:], double[:], double[:])', nopython=True, nogil=True)
15 | def inner_func_nb(result, a, b):
16 |     for i in range(len(result)):
17 |         result[i] = np.exp(2.1 * a[i] + 3.2 * b[i])
18 | 


--------------------------------------------------------------------------------
/src/chapter12/spd_numexpr.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | import numexpr as ne
 3 | import numpy as np
 4 | 
 5 | # 大きなNumPyの配列を作る
 6 | N = 10000000
 7 | a = np.random.randn(N)
 8 | b = np.random.randn(N)
 9 | 
10 | # NumPyに三角関数計算と積和演算をさせて時間を計測
11 | ts1 = time.clock()
12 | c1 = (a * np.sin(b)).sum()
13 | te1 = time.clock()
14 | print('NumPy : %.6f [s]' % (te1 - ts1))
15 | 
16 | # Numexprに上記と同じ計算をさせて時間を計測
17 | ts2 = time.clock()
18 | c2 = ne.evaluate('sum(a * sin(b))')
19 | te2 = time.clock()
20 | print('Numexpr : %.6f [s]' % (te2 - ts2))
21 | 
22 | # どれくらい高速化できたか評価する
23 | print('%.3f[％] 早く処理できました。' % (100-100*(te2-ts2)/(te1-ts1)))
24 | 


--------------------------------------------------------------------------------
/src/chapter2/Readme.txt:
--------------------------------------------------------------------------------
1 | 第２章のロケットシミュレーションプログラムのソースコードは
2 | 以下のGitHubレポジトリを参照してください。
3 | 
4 | https://github.com/pyjbooks/PyRockSim.git
5 | 
6 | 


--------------------------------------------------------------------------------
/src/chapter3/fc.py:
--------------------------------------------------------------------------------
 1 | """ fc.py """
 2 | import numpy as np
 3 | n = 20
 4 | 
 5 | 
 6 | def func_c():
 7 |     a = np.arange(0, n*n).reshape(n, n) + np.identity(n)
 8 |     b = np.arange(0, n)
 9 |     x = np.dot(np.linalg.inv(a), b)
10 | 


--------------------------------------------------------------------------------
/src/chapter3/filelist.txt:
--------------------------------------------------------------------------------
1 | p.80  : myscript.py
2 | p.87  : prun1.py
3 | p.88  : fc.py
4 | p.90  : prun2.py
5 | 
6 | 


--------------------------------------------------------------------------------
/src/chapter3/myscript.py:
--------------------------------------------------------------------------------
 1 | def my_add(x, y):
 2 |     """ 2つの数字を加算する """
 3 |     out = x + z  # バグ：zという変数は定義されていない
 4 |     return out + y
 5 | 
 6 | if __name__ == "__main__":
 7 |     a, b = 3, 4
 8 |     z = my_add(a, b)
 9 |     print(z)
10 | 


--------------------------------------------------------------------------------
/src/chapter3/prun1.py:
--------------------------------------------------------------------------------
 1 | """ prun1.py """
 2 | import numpy as np
 3 | 
 4 | 
 5 | def func_a():
 6 |     a = np.random.randn(500, 500)
 7 |     return a**2
 8 | 
 9 | 
10 | def func_b():
11 |     a = np.random.randn(1000, 1000)
12 |     return a**2
13 | 
14 | 
15 | def func_both():
16 |     a = func_a()
17 |     b = func_b()
18 |     return [a, b]
19 | 
20 | if __name__ == '__main__':
21 |     func_both()
22 | 


--------------------------------------------------------------------------------
/src/chapter3/prun2.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from memory_profiler import profile
 3 | 
 4 | 
 5 | @profile  # 次の関数はメモリプロファイラの分析対象とする
 6 | def func_a():
 7 |     a = np.random.randn(500, 500)
 8 |     return a**2
 9 | 
10 | 
11 | @profile  # 次の関数はメモリプロファイラの分析対象とする
12 | def func_b():
13 |     a = np.random.randn(1000, 1000)
14 |     return a**2
15 | 
16 | 
17 | def func_both():
18 |     a = func_a()
19 |     b = func_b()
20 |     return [a, b]
21 | 
22 | if __name__ == '__main__':
23 |     func_both()
24 | 


--------------------------------------------------------------------------------
/src/chapter4/decorator_1.py:
--------------------------------------------------------------------------------
 1 | # デコレータ（debug_log）の機能を有効にするためのフラグ
 2 | debug_trace = True
 3 | # 上記フラグが有効の場合、ログファイルを開く
 4 | if debug_trace:
 5 |     log_file = open("debug.log", "w", encoding='utf-8')
 6 | 
 7 | 
 8 | # デコレータ関数の定義
 9 | def debug_log(func):
10 |     if debug_trace:
11 |         def func_and_log(*args, **kwargs):
12 |             # funcの実行前にログファイルに記録
13 |             log_file.write("開始 %s: %s, %s\n" %
14 |                            (func.__name__, args, kwargs))
15 |             # funcをそのまま実行
16 |             r = func(*args, **kwargs)
17 |             # func終了時に再度ログファイルに記録
18 |             log_file.write("終了 %s: 返り値 %s\n" % (func.__name__, r))
19 |             return r
20 |         return func_and_log
21 |     else:
22 |         return func  # debug_trace = False なら何も変えない
23 | 
24 | 
25 | # デコレータでmyFuncの機能を変更
26 | @debug_log
27 | def myfunc(x):
28 |     return x+x
29 | 
30 | # デコレータで変更後のmyFuncを実行
31 | myfunc(3)
32 | myfunc(5)
33 | log_file.close()  # ログファイルを閉じる
34 | 


--------------------------------------------------------------------------------
/src/chapter4/filelist.txt:
--------------------------------------------------------------------------------
1 | p.157 : decorator_1.py
2 | p.160 : module_1.py
3 | p.161 : module_2.py
4 | 
5 | 


--------------------------------------------------------------------------------
/src/chapter4/module_1.py:
--------------------------------------------------------------------------------
 1 | # ファイル名: module_1.py """
 2 | print("module_1 is imported.")
 3 | wgt = 60.5  # 初期体重 [kg]
 4 | 
 5 | 
 6 | def teacher(x):
 7 |     if x > 60:
 8 |         print("体重オーバーです")
 9 |     else:
10 |         print("適正体重です")
11 | 


--------------------------------------------------------------------------------
/src/chapter4/module_2.py:
--------------------------------------------------------------------------------
 1 | # ファイル名: module_2.py
 2 | import module_1  # module_1をimportして内部のプログラムを実行
 3 | 
 4 | 
 5 | # module_1の内部の変数にアクセス
 6 | weight = module_1.wgt
 7 | # 以下、複数回にわたり、module_1の内部の関数にアクセス
 8 | module_1.teacher(weight)  # module_1の関数にアクセス
 9 | weight = module_1.run(weight)  # module_1の
10 | module_1.teacher(weight)
11 | 


--------------------------------------------------------------------------------
/src/chapter5/class1.py:
--------------------------------------------------------------------------------
 1 | # クラスの定義
 2 | class MyClass(object):  # (1)継承するクラスなし
 3 |     """ (2)簡単なクラスの例のDocstring """
 4 |     # (3)クラスのデータx、yの定義
 5 |     x = 0
 6 |     y = 0
 7 | 
 8 |     def my_print(self):
 9 |         self.x += 1  # xをインスタンス固有のオブジェクトとして扱う
10 |         MyClass.y += 1  # yをクラス固有のオブジェクトとして扱う
11 |         print('(x, y) = ({}, {})'.format(self.x, self.y))
12 | 
13 | 
14 | # クラスのインスタンス化
15 | f = MyClass  # (5)()が付いてない場合はクラスに別名を付けただけ
16 | a = MyClass()  # (6)MyClassクラスのインスタンスを生成しaという名前を付ける
17 | b = f()  # (7)f()はMyClass()と同じ意味（別名を使っている。(5)参照）
18 | # (8)メソッドの実行
19 | a.my_print()
20 | b.my_print()
21 | b.my_print()
22 | 


--------------------------------------------------------------------------------
/src/chapter5/class2.py:
--------------------------------------------------------------------------------
 1 | # クラスの定義
 2 | class MyClass(object):  # 継承するクラス無し
 3 |     """ 簡単なクラスの例のDocstring """
 4 | 
 5 |     def __init__(self, x, y):
 6 |         self.x = x
 7 |         self.y = y
 8 |         
 9 |     def my_print(self):
10 |         print('{}年のオリンピック開催地は{}'.format(self.x, self.y))
11 | 
12 | # クラスのインスタンス化
13 | a = MyClass(2016, 'リオデジャネイロ')
14 | b = MyClass(2020, '東京')
15 | # メソッドの実行
16 | a.my_print()
17 | b.my_print()
18 | 


--------------------------------------------------------------------------------
/src/chapter5/class3.py:
--------------------------------------------------------------------------------
 1 | # (1)グローバル名前空間にxを定義
 2 | x = 100
 3 | 
 4 | 
 5 | class MyClass:
 6 |     # (2)このクラスのデータとしてiとxを定義
 7 |     i = 10  # メソッドprice()の中で参照される
 8 |     x += 2  # グローバル名前空間のxに２を加えてデータxを定義
 9 |     xx = x + 2  # (3)MyClassの中のデータのxを参照
10 |     print('xx = ', xx)
11 | 
12 |     def price(self):
13 |         y = self.i * x  # (4)グローバル名前空間のオブジェクトxを参照
14 |     z = self.i * self.x  # (5)インスタンス属性→クラス属性の順に検索して参照
15 |     # z = i * x  # (6)これはエラー（ここからデータiは見えない）
16 |     print("price y = %d" % y)
17 |     print("price z = %d" % z)
18 | 
19 |     def shop(self):
20 |         # price()  # (7)エラーとなる（NameError）
21 |         self.price()  # (8)これはOK
22 |         # MyClass.price(self) # (9)これでもOK
23 |         MyClass.i = 20  # (10)クラスのデータを変更
24 |         print("メソッド shop 終了")
25 | 
26 | 
27 | # (11)動作確認のための実行コード
28 | if __name__ == '__main__':
29 |     a = MyClass()
30 |     b = MyClass()
31 |     a.shop()  # この中で MyClass.i = 20 が実行される
32 |     print('(a.i, b.i) = ({}, {})'.format(a.i, b.i))
33 |     a.i = 2  # インスタンス属性を設定
34 |     MyClass.i = 4  # クラス属性の値を変更
35 |     print('(a.i, b.i) = ({}, {})'.format(a.i, b.i))
36 | 


--------------------------------------------------------------------------------
/src/chapter5/classmethod1.py:
--------------------------------------------------------------------------------
 1 | # クラスCoeffVarを定義
 2 | class CoeffVar(object):
 3 |     coefficient = 1
 4 | 
 5 |     @classmethod  # メソッドmulをクラスメソッド化
 6 |     def mul(cls, fact):  # 第1引数はcls
 7 |         return cls.coefficient * fact
 8 | 
 9 | 
10 | # クラスCoeffvarを継承するクラスMulFiveを定義
11 | class MulFive(CoeffVar):
12 |     coefficient = 5
13 | 
14 | 
15 | x = MulFive.mul(4)  # CoeffVar.mul(MulFive, 4) -> 20
16 | 


--------------------------------------------------------------------------------
/src/chapter5/filelist.txt:
--------------------------------------------------------------------------------
 1 | p.173  : class1.py
 2 | p.175  : class2.py
 3 | p.177  : inheritance1.py
 4 | p.179(リスト5.4) : static1.py
 5 | p.179(リスト5.5) : instance1.py
 6 | p.180  : classmethod1.py
 7 | p.182  : scope_error.py
 8 | p.183  : class3.py
 9 | 
10 | 
11 | 


--------------------------------------------------------------------------------
/src/chapter5/inheritance1.py:
--------------------------------------------------------------------------------
 1 | # (1)クラスMyBaseの定義（MyDerivの基底クラス）
 2 | class MyBase(object):
 3 |     coeff = 2
 4 | 
 5 |     def __init__(self, x):
 6 |         self.x = x
 7 | 
 8 |     def mult(self):
 9 |         return self.coeff * self.x
10 | 
11 | 
12 | # (2)クラスMyDerivの定義（MyBaseの派生クラス）
13 | class MyDeriv(MyBase):
14 |     coeff = 3  # (3)属性を再定義
15 | 
16 |     # (4)コンストラクタの再定義
17 |     def __init__(self, x, y):
18 |         super().__init__(x)  # (5)基底クラスのメソッドの呼び出し例
19 |         self.y = y  # (6)属性yを追加しインスタンス化時に初期化
20 | 
21 |     # (7)新しいメソッドを追加
22 |     def mult2(self):
23 |         return self.coeff * self.x * self.y
24 | 
25 | 
26 | # (8)MyBaseとMyDerivを使った計算例
27 | a = MyBase(3)  # MyBaseのインスタンスを生成
28 | print(a.mult())  # 結果は 2*3=6
29 | b = MyDeriv(3, 5)  # MyDerivのインスタンスを生成
30 | print(b.mult())  # 結果は 3*3=9 （継承したメソッドの確認）
31 | print(b.mult2())  # 結果は 3*5*5=45（追加したメソッドの確認）
32 | 


--------------------------------------------------------------------------------
/src/chapter5/instance1.py:
--------------------------------------------------------------------------------
 1 | import time
 2 | 
 3 | 
 4 | class MyTime(object):
 5 |     def __init__(self, hour, minutes, sec):
 6 |         self.hour = hour
 7 |         self.minutes = minutes
 8 |         self.sec = sec
 9 | 
10 |     @staticmethod  # now()をスタティックメソッド化
11 |     def now():
12 |         t = time.localtime()
13 |         return MyTime(t.tm_hour, t.tm_min, t.tm_sec)
14 | 
15 |     @staticmethod  # two_hours_later()をスタティックメソッド化
16 |     def two_hours_later():
17 |         t = time.localtime(time.time() + 7200)
18 |         return MyTime(t.tm_hour, t.tm_min, t.tm_sec)
19 | 
20 | # クラスMyTimesのインスタンス化を3つの方法で行う
21 | a = MyTime(15, 20, 58)  # __init__を使う通常のインスタンス化
22 | b = MyTime.now()  # スタティックメソッドによるインスタンス化(1)
23 | c = MyTime.two_hours_later()  # スタティックメソッドによるインスタンス化(2)
24 | 


--------------------------------------------------------------------------------
/src/chapter5/scope_error.py:
--------------------------------------------------------------------------------
 1 | x = 10
 2 | 
 3 | 
 4 | class MyClass(object):
 5 |     x = 3  # xが所属する名前空間は生成される
 6 | 
 7 |     def __init__(self, y):
 8 |         self.x += y
 9 | 
10 |     def my_add(self, z):
11 |         x = x + z  # エラー： xのスコープは生成されていない
12 |         # self.x とすれば参照可能
13 | 
14 | 
15 | if __name__ == '__main__':
16 | a = MyClass(10)
17 | a.my_add(10)
18 | print(a.x)
19 | 


--------------------------------------------------------------------------------
/src/chapter5/static1.py:
--------------------------------------------------------------------------------
1 | class MyCalc(object):
2 |     @staticmethod
3 |     def my_add(x, y):
4 |         return x + y
5 | 
6 | a = MyCalc.my_add(5, 9)  # a = 14 となる（MyCalcのインスタンスを作成しなくてよい）
7 | 


--------------------------------------------------------------------------------
/src/chapter6/csv_read1.py:
--------------------------------------------------------------------------------
 1 | import csv # 標準モジュールcsvを読み込んで使用可能にする
 2 | 
 3 | 
 4 | # CSVファイルの読み出し
 5 | with open('data1.csv', 'r', encoding='utf8') as f:
 6 |     dat = [k for k in csv.reader(f)] # リスト内包表記を使う
 7 | 
 8 | # CSVファイルの書き込み
 9 | with open('out.csv', 'w', newline='') as f:
10 |     writer = csv.writer(f)
11 |     writer.writerows(dat)
12 | 


--------------------------------------------------------------------------------
/src/chapter6/csv_read2.py:
--------------------------------------------------------------------------------
 1 | import numpy as np  # NumPyをimport
 2 | import csv  # 標準モジュールcsvを読み込む
 3 | 
 4 | 
 5 | # CSVファイルからの読み込み
 6 | dat = np.loadtxt('data1.csv', delimiter=',', skiprows=1, dtype=float)
 7 | 
 8 | # ndarrayのdatをCSVファイルへ書き込み（日本語を扱えない点に注意）
 9 | np.savetxt('data1_saved.csv', dat, fmt='%.1f,%.8f,%d',
10 |            header='time,vel,alt', comments='')
11 | 
12 | # ndarrayのdatをCSVファイルの書き込み（日本語も扱える）
13 | with open('out.csv', 'w', newline='', encoding='utf-8') as f:
14 |     f.write('time,速度,高度\n')
15 |     writer = csv.writer(f)
16 |     writer.writerows(dat)
17 | 


--------------------------------------------------------------------------------
/src/chapter6/data1.csv:
--------------------------------------------------------------------------------
 1 | time,速度,高度
 2 | 0.1,0,10
 3 | 0.2,7.532680553,20
 4 | 0.3,11.28563849,35
 5 | 0.4,15.02255891,40
 6 | 0.5,18.73813146,42
 7 | 0.6,22.42707609,43
 8 | 0.7,26.08415063,60
 9 | 0.8,29.70415816,80
10 | 0.9,33.28195445,121
11 | 1,36.81245527,150
12 | 


--------------------------------------------------------------------------------
/src/chapter6/excel_read1.py:
--------------------------------------------------------------------------------
 1 | import xlwt  # Excelファイル書き込み用
 2 | import xlrd  # Excelファイル読み出し用
 3 | 
 4 | # --- Excelファイルの書き込み
 5 | # Work bookを準備
 6 | wb = xlwt.Workbook()
 7 | # シートを追加
 8 | ws = wb.add_sheet('シート1')
 9 | # シートの特定のセルに値を入れる
10 | ws.write(0, 0, 'Upper Left')
11 | ws.write(1, 0, 1)
12 | ws.write(1, 1, 2)
13 | ws.write(1, 2, xlwt.Formula("A3+B3"))
14 | # Work bookに名前を付けて保存
15 | wb.save('xlwt.xls')
16 | 
17 | # --- Excelファイルの読み出し
18 | # 読み出すWork bookを指定して開く
19 | wb = xlrd.open_workbook('xlwt.xls')
20 | # シートを名前で指定する
21 | st = wb.sheet_by_name('シート1')
22 | # 指定したシートの特定のセルの値を読み出して表示
23 | print(st.cell(0, 0).value)
24 | 


--------------------------------------------------------------------------------
/src/chapter6/filelist.txt:
--------------------------------------------------------------------------------
 1 | p.193  : data1.csv
 2 | p.194  : csv_read1.py
 3 | p.195  : csv_read2.py
 4 | p.197  : excel_read1.py
 5 | p.198  : openpyxl1.py
 6 | p.199  : pickle1.py
 7 | p.200  : pickle2.py
 8 | p.201  : pickle3.py
 9 | p.202  : npynpz1.py
10 | p.203  : ndf5-1.py
11 | p.203  : matread1.py
12 | 
13 | 


--------------------------------------------------------------------------------
/src/chapter6/hdf5-1.py:
--------------------------------------------------------------------------------
 1 | import h5py
 2 | import numpy as np
 3 | 
 4 | # 保存するデータを生成
 5 | t = np.arange(0, 5, 0.1)
 6 | y = np.sin(2*np.pi*0.3*t)
 7 | dist = [2, 5, 1, 3, 8, 9, 12]
 8 | 
 9 | # データの一部を階層構造にして保存
10 | with h5py.File('data1.h5', 'w') as f:
11 |     f.create_group('wave')
12 |     f.create_dataset('wave/t', data=t)
13 |     f.create_dataset('wave/y', data=y)
14 |     f.create_dataset('dist', data=dist)
15 | 
16 | # withブロックを抜けると f は一旦閉じられる
17 | 
18 | # データの読み出し
19 | with h5py.File('data1.h5', 'r') as f:
20 |     t = np.array(f['wave/t'])  # 以下、ndarrayとして読み出し
21 |     y = np.array(f['wave/y'])
22 |     dist = np.array(f['dist'])
23 | 


--------------------------------------------------------------------------------
/src/chapter6/matread1.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import scipy as sp
 3 | 
 4 | # 保存するデータを生成
 5 | t = np.arange(0, 5, 0.1)
 6 | y = np.sin(2*np.pi*0.3*t)
 7 | 
 8 | # MAT-fileの書き出し例
 9 | out_dat = {}
10 | out_dat['time'] = t  # ndarrayのtをtimeという名前で格納
11 | out_dat['y'] = y
12 | sp.io.savemat('data2.mat', out_dat, format='5')
13 | 
14 | # MAT-fileの読み込み例
15 | matdat = sp.io.loadmat('data1.mat', squeeze_me=True)
16 | tt = matdat['time']  # ndarray が生成される
17 | 


--------------------------------------------------------------------------------
/src/chapter6/npynpz1.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | 
 3 | # npyにndarrayを1つ保存
 4 | a = np.array([1, 2, 3])
 5 | np.save('foo', a)
 6 | 
 7 | # npyからndarrayを復元
 8 | a2 = np.load('foo.npy')
 9 | 
10 | # npz（複数のndarrayアーカイブ）にndarrayを出力
11 | b = np.array([[1, 2], [3, 4]])
12 | np.savez('foo.npz', a=a, b2=b)  # bにb2という名前を付けて保存
13 | 
14 | # npzファイルの入力
15 | with np.load('foo.npz') as data:
16 |     a3 = data['a']  # aという名前の変数だけ取り出す
17 |     b3 = data['b2']
18 | 


--------------------------------------------------------------------------------
/src/chapter6/openpyxl1.py:
--------------------------------------------------------------------------------
 1 | # openpyxlから必要な関数（load_workbook）をimport
 2 | from openpyxl import load_workbook
 3 | import numpy as np  # NumPyもimport
 4 | 
 5 | # WorkBookを開く
 6 | wb = load_workbook(filename='Sample1.xlsx', read_only=True,
 7 |                    data_only=True, use_iterators=True)
 8 | # WorkSheetを名前で指定
 9 | ws = wb['温度変化']
10 | 
11 | # あらかじめデータを格納するNumPyのndarrayを作成しておく
12 | Nrow = 11
13 | time_vec = np.zeros(Nrow)
14 | temp_vec = np.zeros(Nrow)
15 | 
16 | # データの読み出し
17 | for i, row in enumerate(ws.iter_rows(row_offset=1)):
18 |     time_vec[i] = row[0].value
19 |     temp_vec[i] = row[1].value
20 | 


--------------------------------------------------------------------------------
/src/chapter6/pickle1.py:
--------------------------------------------------------------------------------
 1 | import pickle  # 標準ライブラリpickleの読み込み
 2 | 
 3 | # 保存するオブジェクトの準備
 4 | mydata = [1, 2, 3]
 5 | 
 6 | # オブジェクト（mydata）をファイル'pickle1.pickle'（拡張子は.pickleでなくても良い）に保存
 7 | with open('pickle1.pickle', 'wb') as f:
 8 |     pickle.dump(mydata, f)
 9 | 
10 | # ファイル'pickle1.pickle'からデータを取り出してdatに代入
11 | with open('pickle1.pickle', 'rb') as f:
12 |     dat = pickle.load(f)
13 | 


--------------------------------------------------------------------------------
/src/chapter6/pickle2.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | import numpy as np
 3 | 
 4 | 
 5 | # 保存ｌするオブジェクトの準備
 6 | a = np.float(2.3)
 7 | b = np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]])
 8 | c = {'yokohama': 1, 'tokyo': 2, 'nagoya': 3}
 9 | 
10 | # 複数オブジェクトを1つのファイルにpickle化
11 | with open('pickle1.pickle', 'wb') as f:
12 |     pickle.dump(a, f)
13 |     pickle.dump(b, f)
14 |     pickle.dump(c, f)
15 | 
16 | # pickle化したファイルから複数オブジェクトを読み出す
17 | with open('pickle1.pickle', 'rb') as f:
18 |     a2 = pickle.load(f)
19 |     b2 = pickle.load(f)
20 |     c2 = pickle.load(f)
21 | 


--------------------------------------------------------------------------------
/src/chapter6/pickle3.py:
--------------------------------------------------------------------------------
 1 | import pickle
 2 | import numpy as np
 3 | 
 4 | 
 5 | def pickle_vars(fname, mode='wb', **vars):
 6 |     """
 7 |     使い方
 8 |     pickle_vars('作成するファイル名', a=a, b=b, c=c)
 9 |     引数には作成するファイル名と、オブジェクトを列挙する
10 |     """
11 |     dic = {}
12 |     for key in vars.keys():
13 |         exec('dic[key]=vars.get(key)')
14 |     with open(fname, mode) as f:
15 |         pickle.dump(dic, f)
16 |     return dic
17 | 
18 | if __name__ == "__main__":
19 |     # 各種オブジェクトを生成
20 |     a = np.float(2.3)
21 |     b = np.array([[1.1, 2.2, 3.3], [4.4, 5.5, 6.6]])
22 |     c = {'yokohama': 1, 'tokyo': 2, 'nagoya': 3}
23 |     # 複数の変数とそのデータを保存
24 |     saved_dat = pickle_vars('pickle1.pickle', a=a, b=b, c=c)
25 |     # pickle化したファイルからデータを読み出す
26 |     with open('pickle1.pickle', 'rb') as f:
27 |         dat = pickle.load(f)
28 |         for key in dat.keys():
29 |             exec(key+'=dat.get(key)')  # 元の変数でデータを復元
30 | 


--------------------------------------------------------------------------------
/src/chapter7/filelist.txt:
--------------------------------------------------------------------------------
1 | ソースファイルなし
2 | 


--------------------------------------------------------------------------------
/src/chapter8/filelist.txt:
--------------------------------------------------------------------------------
1 | p.252  : plt_rayleigh.py
2 | p.255  : plt_fft.py
3 | p.256  : plt_bode.py
4 | p.258  : plt_interp.py
5 | p.260  : plt_iir.py
6 | 


--------------------------------------------------------------------------------
/src/chapter8/plt_bode.py:
--------------------------------------------------------------------------------
 1 | import scipy as sp
 2 | import matplotlib.pyplot as plt
 3 | 
 4 | # (1)scipyとは別にimportが必要
 5 | from scipy import signal
 6 | 
 7 | # (2)線形システムの定義
 8 | s1 = sp.signal.lti([1], [1, 1])
 9 | 
10 | # (3)bode関数による解析処理
11 | w, mag, phase = sp.signal.bode(s1)
12 | 
13 | # (4)ボード線図の描画
14 | plt.figure(1)
15 | plt.subplot(2, 1, 1)
16 | plt.semilogx(w, mag)  # Bode magnitude plot
17 | plt.box('on')
18 | plt.xlabel('周波数 [rad/s]')
19 | plt.ylabel('ゲイン [dB]')
20 | plt.title('ボード線図')
21 | plt.subplot(2, 1, 2)
22 | plt.semilogx(w, phase)  # Bode phase plot
23 | plt.xlabel('周波数 [rad/s]')
24 | plt.ylabel('位相 [deg]')
25 | plt.box('on')
26 | plt.show()
27 | 


--------------------------------------------------------------------------------
/src/chapter8/plt_fft.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import scipy as sp
 3 | import matplotlib.pyplot as plt
 4 | # (1)scipyとは別にimportが必要
 5 | from scipy.fftpack import fft
 6 | 
 7 | # (2)30 Hzの信号とノイズの合成信号yを生成
 8 | Fs = 500  # サンプリング周波数
 9 | T = 1/Fs  # サンプリング時間
10 | L = 2**14  # 信号の長さ（サンプリング数）
11 | t = sp.arange(L)*T  # 時間ベクトル
12 | y = np.sin(2*np.pi*30*t) + 5*sp.randn(t.size)  # 信号生成
13 | 
14 | # (3)FFTを実行
15 | Y = sp.fftpack.fft(y, L)/L
16 | f = (Fs/L)*sp.arange(L/2 + 1)  # 周波数ベクトル取得
17 | 
18 | # (4)「元の時系列データ」と「FFTによる周波数解析結果」のプロット
19 | plt.figure(1)
20 | plt.subplot(2, 1, 1)
21 | plt.plot(t, y)
22 | plt.xlabel('時間 [s]')
23 | plt.ylabel('値')
24 | plt.subplot(2, 1, 2)
25 | plt.plot(f, 2*abs(Y[:L/2 + 1]))
26 | plt.xlabel('周波数 [Hz]')
27 | plt.ylabel('|Y(f)|')
28 | 


--------------------------------------------------------------------------------
/src/chapter8/plt_iir.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | # (1)scipyとは別にimportが必要
 4 | import scipy.signal as signal
 5 | 
 6 | # (2)Chebyshev I型のフィルタ設計
 7 | b1, a1 = signal.iirfilter(4, Wn=0.2, rp=5, rs=40,
 8 |                           btype='lowpass', ftype='cheby1')
 9 | w1, h1 = signal.freqz(b1, a1)
10 | 
11 | # (3)Cauer/elliptic型のフィルタ設計
12 | b2, a2 = signal.iirfilter(4, Wn=0.2, rp=5, rs=40,
13 |                           btype='lowpass', ftype='ellip')
14 | w2, h2 = signal.freqz(b2, a2)
15 | 
16 | # (4)フィルタの周波数特性のプロット
17 | plt.title('周波数特性')
18 | plt.plot(w1, 20*np.log10(np.abs(h1)), 'k-', label='Chebyshev I')
19 | plt.plot(w2, 20*np.log10(np.abs(h2)), 'k--', label='Cauer/elliptic')
20 | plt.legend(loc='best')
21 | plt.ylabel('振幅 [dB]')
22 | plt.xlabel('周波数 [rad/sample]')
23 | plt.show()
24 | 


--------------------------------------------------------------------------------
/src/chapter8/plt_interp.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | 
 4 | # (1)名前が長いので別名を付ける
 5 | import scipy.interpolate as ipl
 6 | 
 7 | 
 8 | # (2)元の関数の定義
 9 | def f(x):
10 |     return (x-7) * (x-2) * (x+0.2) * (x-4)
11 | 
12 | # (3)元データ生成（正解の値）
13 | x = np.linspace(0, 8, 81)
14 | y = np.array(list(map(f, x)))
15 | 
16 | # (4)補間前の間隔が広いデータ
17 | x0 = np.arange(9)
18 | y0 = np.array(list(map(f, x0)))
19 | 
20 | # (5)補間関数の設定（線形補間）
21 | #  補間関数の設定（線形補間／3次スプライン）
22 | f_linear = ipl.interp1d(x0, y0, bounds_error=False)
23 | f_cubic = ipl.interp1d(x0, y0, kind='cubic', bounds_error=False)
24 | #  補間処理の実行
25 | y1 = f_linear(x)  # 線形補間
26 | y2 = f_cubic(x)  # 3次スプライン補間
27 | 
28 | # (6)補間データと元データの比較プロット
29 | plt.figure(1)
30 | plt.clf()
31 | plt.plot(x, y, 'k-', label='元の関数')
32 | plt.plot(x0, y0, 'ko', label='補間前データ', markersize=10)
33 | plt.plot(x, y1, 'k:', label='線形補間', linewidth=4)
34 | plt.plot(x, y2, 'k--', label='3次スプライン補間', linewidth=4, alpha=0.7)
35 | plt.legend(loc='best')
36 | plt.xlabel('x')
37 | plt.ylabel('y')
38 | plt.grid('on')
39 | 


--------------------------------------------------------------------------------
/src/chapter8/plt_rayleigh.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import scipy as sp
 3 | import scipy.stats
 4 | import matplotlib.pyplot as plt
 5 | 
 6 | plt.style.use('ggplot')
 7 | 
 8 | # (1)統計分布関数の設定（Freezeしておく）
 9 | rv = sp.stats.rayleigh(loc=1)
10 | 
11 | # (2)上記統計分布関数によるランダム変数の生成
12 | r = rv.rvs(size=3000)
13 | 
14 | # (3)確率密度関数プロット用のパーセント点データ列
15 | x = np.linspace(rv.ppf(0.01), rv.ppf(0.99), 100)
16 | 
17 | # 元の確率密度関数と一緒にサンプルしたデータの分布をプロットする
18 | plt.figure(1)
19 | plt.clf()
20 | plt.plot(x, rv.pdf(x), 'k-', lw=2, label='確率密度関数')
21 | plt.hist(r, normed=True, histtype='barstacked', alpha=0.5)
22 | plt.xlabel('値')
23 | plt.ylabel('分布度')
24 | plt.show()
25 | 


--------------------------------------------------------------------------------
/src/chapter9/filelist.txt:
--------------------------------------------------------------------------------
1 | p.278  : simple_2d.py
2 | p.280  : subplot_2x3.py
3 | p.280  : plt_gridspec.py
4 | p.282  : plt_in_plt.py
5 | p.283  : plt_contour.py
6 | p.286  : plt_3d.py
7 | 
8 | 


--------------------------------------------------------------------------------
/src/chapter9/plt_3d.py:
--------------------------------------------------------------------------------
 1 | from mpl_toolkits.mplot3d.axes3d import Axes3D
 2 | import matplotlib.pyplot as plt
 3 | import numpy as np
 4 | from matplotlib import cm
 5 | from matplotlib.mlab import bivariate_normal
 6 | 
 7 | # 2次元メッシュを作成
 8 | N = 200
 9 | x = np.linspace(-3.0, 3.0, N)
10 | y = np.linspace(-2.0, 2.0, N)
11 | X, Y = np.meshgrid(x, y)
12 | 
13 | # 2変量正規分布で2次元分布データを作成
14 | z = 15 * (bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0) -
15 |           bivariate_normal(X, Y, 1.5, 0.5, 1, 1))
16 | 
17 | # データを3次元プロットする
18 | fig = plt.figure(1)  # (1)
19 | ax = fig.add_subplot(111, projection='3d')  # (2)
20 | surf = ax.plot_surface(X, Y, z, cmap=cm.gray)
21 | ax.set_zlim3d(-3.01, 3.01)
22 | plt.colorbar(surf, shrink=0.5, aspect=10)
23 | plt.show()
24 | 


--------------------------------------------------------------------------------
/src/chapter9/plt_contour.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | from matplotlib import cm
 4 | from matplotlib.mlab import bivariate_normal
 5 | 
 6 | # 2次元メッシュを作成
 7 | N = 200
 8 | x = np.linspace(-3.0, 3.0, N)
 9 | y = np.linspace(-2.0, 2.0, N)
10 | X, Y = np.meshgrid(x, y)
11 | 
12 | # 2変量正規分布で2次元分布データを作成
13 | z = 15 * (bivariate_normal(X, Y, 1.0, 1.0, 0.0, 0.0) -
14 |           bivariate_normal(X, Y, 1.5, 0.5, 1, 1))
15 | 
16 | # --- プロットを作成
17 | plt.figure(1)
18 | 
19 | # (1)zの値を濃淡の画像として表示
20 | im = plt.imshow(z, interpolation='bilinear', origin='lower',
21 |                 cmap=cm.gray, extent=(-3, 3, -2, 2))
22 | 
23 | # (2)等高線を表示
24 | levels = np.arange(-3, 2.5, 0.5)
25 | ctr = plt.contour(z, levels, colors='k', origin='lower',
26 |                   linewidths=2, extent=(-3, 3, -2, 2))
27 | 
28 | # (3)等高線にラベルをインライン表示
29 | plt.clabel(ctr, levels, inline=1, colors='black',
30 |            fmt='%1.1f', fontsize=14)
31 | plt.show()
32 | 


--------------------------------------------------------------------------------
/src/chapter9/plt_gridspec.py:
--------------------------------------------------------------------------------
 1 | import matplotlib.pyplot as plt
 2 | import matplotlib.gridspec as gs
 3 | import numpy as np
 4 | 
 5 | G = gs.GridSpec(3, 3)  # ← (1)
 6 | 
 7 | axes_1 = plt.subplot(G[0, :])  # ← (2)
 8 | plt.xticks([]), plt.yticks([])
 9 | plt.text(0.5, 0.5, '図枠1', ha='center', va='center', size=22)
10 | 
11 | axes_2 = plt.subplot(G[1, :-1])
12 | x = np.arange(-np.pi, np.pi, 0.1)
13 | y = np.sin(x)
14 | plt.plot(x, y)
15 | plt.text(-0.5, 0, '図枠2', ha='center', va='center', size=22)
16 | 
17 | axes_3 = plt.subplot(G[1:, -1])
18 | plt.xticks([]), plt.yticks([])
19 | plt.text(0.5, 0.5, '図枠3', ha='center', va='center', size=22)
20 | 
21 | axes_4 = plt.subplot(G[-1, 0])
22 | plt.xticks([]), plt.yticks([])
23 | plt.text(0.5, 0.5, '図枠4', ha='center', va='center', size=22)
24 | 
25 | axes_5 = plt.subplot(G[-1, -2])
26 | plt.xticks([]), plt.yticks([])
27 | plt.text(0.5, 0.5, '図枠5', ha='center', va='center', size=22)
28 | 
29 | plt.show()
30 | 


--------------------------------------------------------------------------------
/src/chapter9/plt_in_plt.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | import matplotlib.pyplot as plt
 3 | 
 4 | # サブプロットを2つ並べる
 5 | plt.figure(1)
 6 | plt.subplot(2, 1, 1)
 7 | x = np.arange(-np.pi, np.pi, 0.1)
 8 | plt.plot(x, np.sin(x))
 9 | plt.subplot(2, 1, 2)
10 | plt.plot(x, np.cos(x))
11 | 
12 | # 図枠の中に図枠を設定
13 | plt.axes([0.55, 0.3, 0.3, 0.4])
14 | plt.text(0.5, 0.5, 'axes([0.55, 0.3, 0.3, 0.4])', ha='center', va='center')
15 | plt.show()
16 | 


--------------------------------------------------------------------------------
/src/chapter9/simple_2d.py:
--------------------------------------------------------------------------------
 1 | import numpy as np
 2 | from numpy import sin, cos
 3 | import matplotlib.pyplot as plt
 4 | 
 5 | # (1)-πからπまで0.1刻みの配列をつくる
 6 | x = np.arange(-np.pi, np.pi, 0.1)
 7 | # 配列xに対してsin(x)を計算（sin()はユニバーサル関数）
 8 | y1 = sin(x)
 9 | # 配列xに対してcos(x)を計算
10 | y2 = cos(x)
11 | plt.figure(1)
12 | plt.clf()
13 | 
14 | # x、yを描画
15 | plt.plot(x, y1, label='正弦関数')
16 | plt.plot(x, y2, 'r*', markersize=10, label='余弦関数')  # (2)
17 | # 軸ラベル設定
18 | plt.xlabel('X軸')
19 | plt.ylabel('Y軸')
20 | # 凡例の描画
21 | plt.legend(loc='best')
22 | # (3)描画
23 | plt.show()
24 | 


--------------------------------------------------------------------------------
/src/chapter9/subplot_2x3.py:
--------------------------------------------------------------------------------
 1 | import matplotlib.pyplot as plt
 2 | 
 3 | plt.figure(1), plt.clf()
 4 | 
 5 | plt.subplot(2, 3, 1), plt.xticks([]), plt.yticks([])
 6 | plt.text(0.5, 0.5, 'subplot(2,3,1)', ha='center', va='center', size=25)
 7 | plt.subplot(2, 3, 2), plt.xticks([]), plt.yticks([])
 8 | plt.text(0.5, 0.5, 'subplot(2,3,2)', ha='center', va='center', size=25)
 9 | plt.subplot(2, 3, 3), plt.xticks([]), plt.yticks([])
10 | plt.text(0.5, 0.5, 'subplot(2,3,3)', ha='center', va='center', size=25)
11 | plt.subplot(2, 3, 4), plt.xticks([]), plt.yticks([])
12 | plt.text(0.5, 0.5, 'subplot(2,3,4)', ha='center', va='center', size=25)
13 | plt.subplot(2, 3, 5), plt.xticks([]), plt.yticks([])
14 | plt.text(0.5, 0.5, 'subplot(2,3,5)', ha='center', va='center', size=25)
15 | plt.subplot(2, 3, 6), plt.xticks([]), plt.yticks([])
16 | plt.text(0.5, 0.5, 'subplot(2,3,6)', ha='center', va='center', size=25)
17 | 
18 | # プロット全体の表示
19 | plt.show()
20 | 


--------------------------------------------------------------------------------