はじめに

Uplift modeling は、マーケティング施策によって利益を最大化するための手法です。利益がより大きい顧客にターゲットを絞って、メール送付や広告配信などの施策を打つことで、マーケティングの効率化が実現できます。

この記事では、Uplift modeling の概要と、それを実現するための実装例を備忘録としてまとめます。

Uplift modeling

概要

Uplift modelingは、ある属性を持つ顧客の、施策実施による利益の増加分（施策を実施した場合の利益と実施しない場合の利益の差分）を予測する方法です。通常の機械学習による予測タスクでは、施策に対して単純にどう反応するか（予約するか/しないか、予約金額はいくらか、など）を予測しますが、Uplift modelingでは、施策に対して反応がどう変化するか（予約確率や予約金額がどう変化するか）を予測します。顧客の施策に対する反応がどう変化するかを明らかにすることで、効果が高い顧客にのみ施策を実施するターゲッティングや、各顧客に適したマーケティング施策を実施するパーソナライゼーションが可能になります。Uplift modeling で予測されるものは、顧客の属性を条件づけたとき（つまり、同質な属性を持つ顧客）の、施策実施による利益の増加分とも言い換えられるので、CATE （Conditional Average Treatment Effect）、ITE（Indivisual Treatment Effect）とも呼ばれます。

Uplift modeling における顧客の分類

Uplift modeling の枠組みでは、介入（施策の実施）に対してどう反応する（クリックや予約などのコンバージョン（CV）をする）かによって、顧客を4つのセグメントに分類して考えます。

介入あり	介入なし	セグメント名	説明
CVする	CVする	鉄板	介入してもしなくてもCVする
CVする	CVしない	説得可能	介入することではじめてCVする
CVしない	CVする	天邪鬼	介入するとむしろCVしなくなる
CVしない	CVしない	無関心	介入してもしなくてもCVしない

鉄板は、介入してもしなくてもCVする顧客層です。介入にコストがかかる場合はコストが無駄になるので介入すべきではありません。例えば、直近の購買履歴があるアクティブユーザーがこの層に該当し、メール配信などによって購買を喚起しなくても購買してくれる場合は、メール配信のコストが無駄になってしまいます。
説得可能は、介入しない場合はCVしませんが、介入することではじめてCVする顧客層です。例えば、購買意欲はあるものの購買に踏み切れないユーザーがこの層に該当し、割引クーポンなどを配信することで、この層に属するユーザーが購買してくれる可能性が高くなります。
天邪鬼は、介入しない場合はCVしますが、介入するとむしろCVしなくなる顧客層です。介入することで利益が減少するため、絶対に介入してはいけない顧客層です。
無関心は、介入してもしなくてもCVしない顧客層です。例えば、直近の購買から長期間が経過している離反・休眠ユーザーがこの層に該当し、メール配信をしても購買が見込めない場合は、メール配信をやめることでコストを削減することができます。

Uplift modeling は、説得可能に属する顧客層を見極め、これらの顧客を対象に施策を実施することで、効率的なマーケティングを実現します。

Uplift modeling の主なアルゴリズム

Uplift modelingには、主に2つのアルゴリズムがあります。1つは、Meta-Learner アルゴリズムと呼ばれ、介入する場合の利益と介入しない場合の利益を予測するモデル（base-learner と呼びます）を構築し、利益の増加分を推定するアルゴリズムです。もう1つは、Uplift Tree と呼ばれ、「利益の増加分が大きくなるか？」という基準で、顧客の集団を分割する木を構築するアルゴリズムです。

Meta-Learner アルゴリズム

Meta-Learner アルゴリズムには、介入する場合の利益と介入しない場合の利益をどう予測するかによって、さらに T-Learner, S-Learner, X-Learner, R-Learner などのアルゴリズムに分類されます。

T-Learner

介入する場合の利益の予測するモデルと、介入しない場合の利益を予測するモデルを別個に構築し、それぞれの予測値の差分をとることで、利益の増加分を予測するアルゴリズムです。介入する場合と介入しない場合を分けてモデルを構築するため、介入有無は特徴量として採用しません。

式で書くと、

\mu_1(x) = E(Y_1 | X=x)

\mu_0(x) = E(Y_0 | X=x)

\hat{\tau}(x) = \hat{\mu}_1(x) - \hat{\mu}_0(x) 

です。
顧客の背景情報 $x$（デモグラフィック属性や購買履歴など）を特徴量として、介入する場合の利益（予約確率、予約金額など） $Y_1$ を予測するモデルと、介入しない場合の利益 $Y_0$ を予測するモデルを構築し、それらの予測値 $\hat{\mu}_1(x), \hat{\mu}_0(x)$ の差分が、利益の増加分 $\hat{\tau}(x)$ となります。

S-Learner

利益を予測するモデルを1つ構築し、介入する場合と介入しない場合の利益を予測し、それらの差分をとることで、利益の増加分を予測するアルゴリズムです。T-Learner と異なり、介入有無を特徴量として採用します。

式で書くと、

\mu(x, z) = E(Y | X=x, Z=z)

\hat{\tau}(x) = \hat{\mu}(x, Z=1) - \hat{\mu}(x, Z=0)

です。
顧客の背景情報 $x$ と、介入有無を表す群別変数 $z$（$z=1$ は介入あり、$z=0$ を表す）を特徴量として、利益 $Y$ を予測するモデルを構築し、介入する場合の予測値 $\hat{\mu}(x, Z=1)$ と介入しない場合の予測値 $\hat{\mu}(x, Z=0)$ の差分が、利益の増加分 $\hat{\tau}(x)$ となります。

X-Learner

介入する場合と介入しない場合の pseudo-effects（疑似的な利益の増加分）をそれぞれ推定し、それらを重み付けをして足し合わせることで、利益の増加分を予測するアルゴリズムです。

X-Learner は、まず顧客の背景情報 $x$ を特徴量として、介入する場合の利益 $Y_1$ を予測するモデルと、介入しない場合の利益 $Y_0$ を予測するモデルを構築します。

\mu_1(x) = E(Y_1 | X=x)

\mu_0(x) = E(Y_0 | X=x)

そして、介入する場合と介入しない場合の pseudo-effects を以下の式で推定します。

D_i^1 = Y_i^1 - \hat{\mu}_0(x_i^1)

D_i^0 = \hat{\mu}_1(x_i^0) - Y_i^0 

上付き数字は、1は介入した顧客に紐づくデータ、0は介入していない顧客に紐づくデータを利用することを示します。$D_i^1$ は、介入した顧客から得られた利益 $Y_i^1$ と、介入した顧客に仮に介入しなかった場合の利益 $\hat{\mu}_0(x_i^1)$ の差分であり、介入する顧客グループにおける疑似的な利益の増加分を表します。$D_i^0$ は、介入しなかった顧客に仮に介入した場合の利益 $\hat{\mu}_1(x_i^0)$ と、介入しなかった顧客から得られた利益 $Y_i^0$ の差分であり、介入しない顧客における疑似的な利益の増加分を表します。

さらに、顧客の背景情報 $x$ から、pseudo-effects $D_1, D_2$ を予測するモデルを構築します。

\tau_1(x) = E(D_1 | X=x)

\tau_0(x) = E(D_0 | X=x)

最後に、介入する場合の予測値 $\hat{\tau}_0(x)$ と介入しない場合の予測値 $\hat{\tau}_1(x)$ を $g(x)$ で重みを付けて平均をとり、利益の増加分 $\hat{\tau}(x)$ を予測しています。$g(x)$ の値域は $g(x) \in [0,1]$ で、$g(x)$ としては傾向スコア $e(x)=P(Z=1 | X=x)$ を利用することもできます。

\hat{\tau}(x) = g(x)\hat{\tau}_0(x)+(1-g(x))\hat{\tau}_1(x)

R-Learner

R-Learner は、それぞれの顧客から得られる平均的な利益 $m(x)$ と傾向スコア（＝顧客が介入される確率）$e(x)$ を予測し、利益の増加分の予測誤差を最小化するアルゴリズムです。

R-Learner は、まず顧客の背景情報 $x$ を特徴量とし、平均的な利益 $m(x)$、傾向スコア $e(x)$ を予測するモデルを構築します。

m(x) = E(Y | X=x)

e(x) = P(Z=1 | X=x)

そして、利益の増加分の予測誤差（損失関数）$\hat{L}_n(\tau(・))$ が最小になるような、利益の増加分 $\tau(・)$ を求めます。

\hat{\tau}(・) = argmin_{\tau}\{\hat{L}_n(\tau(・)) + \Lambda_n(\tau(・))\}

\hat{L_n(\tau(・))} = \frac{1}{n}\sum_{i=1}^n((Y_i-\hat{m}^{(-i)}(x_i))-(z_i-\hat{e}^{(-i)}(x_i))\tau(x_i))^2

$\Lambda_n(\tau(・))$ は正則化項です。$\hat{m}^{(-i)}(x_i), \hat{e}^{(-i)}(x_i)$ は、顧客 $i$ のデータ以外のデータで構築したモデルで予測した、顧客 $i$ の平均的な利益と傾向スコアを表します。

Uplift Tree

Uplift Tree は、「利益の増加分が大きくなるか？」という基準で、顧客の集団を分割する木を構築するアルゴリズムです。二値分類タスクで用いられる決定木では、分割後の集団におけるクラスの不純度が、分割前に比べて減少するように、ある属性に関する条件で集団を分割します。一方、Uplift Tree では、分割後の集団における、介入ありグループの利益の分布と介入なしグループの利益の分布の距離が、分割前に比べて増加するように、ある属性に関する条件で集団を分割します。つまり、利益の増加に関連が強い属性で顧客集団を分割していきます。

式で書くと、

D_{gain} = D_{after-split}(P^T, P^C) - D_{before-split}(P^T, P^C)

で定義される $D_{gain}$ が大きくなるように木を構築していきます。$P^T, P^C$ は、それぞれ介入ありグループと介入なしグループにおける利益の分布を表し、$D$ は分布の距離を表します。$D$ としては、カルバック・ライブラー情報量や、ユークリッド距離が用いられます。

Uplift modeling の評価指標

Uplift modeling の性能は、AUUC（Area Under the Uplift Curve）という指標を用いて評価します。AUUC は、ランダムに選択した顧客に介入する場合と比較して、Uplift moeling で予測した利益の増加分が大きい顧客にのみ介入する場合、どの程度利益が増加するかを正規化した指標です。AUUCの値が大きいほど、Uplift modeling の性能が高いといえます。AUUC を算出する手順は以下の通りです。

1. Uplift modeling により予測した利益の増加分が大きいほど大きな値をとるように、それぞれの顧客をスコアリングします。ここでは、このスコアを uplift score と呼びます。（利益としてCVRなどの割合を用いている場合、CVR の増加分をそのまま uplift score として利用できます。）
2. uplift score が閾値以上をとる顧客にのみ介入した場合、介入しなかった場合と比較してどれだけ利益が増加したか（ここでは、この値を lift と呼びます）を算出します。
3. 2.で介入する顧客と同数の顧客をランダムに選択し介入した場合の利益の増加分と比較して、2.で求めた lift はどの程度増加するかを算出します。
4. 2., 3. を閾値を変化させて繰り返し算出した lift を足し合わせ、最後に正規化します。（閾値を変化させて得られる lift をプロットした曲線を uplift curve と呼びます。）

式で書くと、

AUUC = \sum_{k=1}^n AUUC_{\pi}(k)

AUUC_{\pi}(k) =  AUL_{\pi}^T(k) - AUL_{\pi}^C(k) = \sum_{i=1}^k (R_{\pi}^T(i) - R_{\pi}^C(i)) - \frac{k}{2}(\bar{R}^T(k) - \bar{R}^C(k))

です。$n$ は全顧客数、$k$ は uplift score が閾値以上となる顧客数、$\pi$ は顧客の順序（uplift socre が大きい順）を表します。$AUL_{\pi}^T(k)$ は、順序 $\pi$ にしたがって $k$ 番目までの顧客に介入した場合の lift、$AUL_{\pi}^C(k)$ は、ランダムに $k$ 人の顧客を選択して介入した場合の利益の増加分です。$R_{\pi}^T(i)$ は、順序 $\pi$ における $i$ 番目の顧客に介入した場合の利益、$R_{\pi}^C(i))$ は、順序 $\pi$ における $i$ 番目の顧客に介入しなかった場合の利益です。$\bar{R}^T(k)$ は、ランダムに選択した $k$ 人に介入した場合の利益、$\bar{R}^C(k)$ は、ランダムに選択した $k$ 人に介入しなかった場合の利益です。$AUL_{\pi}^C(k)$は、底辺 $k$、高さ $\bar{R}^T(k) - \bar{R}^C(k)$ の三角形の面積と見做すこともできます。

実装例

Python で Uplift modeling により利益の増加分を予測するコードを実装します。ここでは、T-Learner, S-Learner を実装しています。なお、ここでの実装は仕事ではじめる機械学習の9章を参考にしています。また、実行環境は、Python 3.7.6, numpy 1.18.1, pandas 1.0.2, scikit-learn 0.22.2 です。以下、コードです。

• 必要なライブラリの読み込み

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
sns.set_style('whitegrid')
import random

from sklearn.linear_model import LogisticRegression

• 利用するデータの生成

ここでの利益は CVR としています。

def generate_sample_data(num, seed=0):
    cv_flg_list = [] # コンバージョンしたかを表すフラグのリスト
    treat_flg_list = [] # 介入したかを表すフラグのリスト
    feature_vector_list = [] # 特徴量のリスト

    feature_num = 8 # 特徴量の数
    base_weight = [0.02, 0.03, 0.05, -0.04, 0.00, 0.00, 0.00, 0.00] # 特徴量のベース
    lift_weight = [0.00, 0.00, 0.00, 0.05, -0.05, 0.00, 0.0, 0.00] # 介入時の特徴量の変化量

    random_instance = random.Random(seed)
    for i in range(num):
        feature_vector = [random_instance.random() for n in range(feature_num)] # 特徴量をランダムに生成
        treat_flg = random_instance.choice((1, 0)) # 介入フラグをランダムに生成
        cv_rate = sum([feature_vector[n]*base_weight[n] for n in range(feature_num)]) # CVRのベースとなる値を生成
        if treat_flg == 1:
            cv_rate += sum([feature_vector[n]*lift_weight[n] for n in range(feature_num)]) # 介入するならlift_weightを加味してCVRを加算
        cv_flg = 1 if cv_rate > random_instance.random() else 0

        cv_flg_list.append(cv_flg)
        treat_flg_list.append(treat_flg)
        feature_vector_list.append(feature_vector)

    df = pd.DataFrame(np.c_[cv_flg_list, treat_flg_list, feature_vector_list], 
                      columns=['cv_flg', 'treat_flg','feature0', 'feature1', 'feature2', 
                               'feature3', 'feature4', 'feature5', 'feature6', 'feature7'])

    return df

train_data = generate_sample_data(num=10000, seed=0) # モデル構築用データ（学習データ）
test_data = generate_sample_data(num=10000, seed=1) # モデル性能評価用データ（検証データ）

• T-Learner の実装

# 介入する場合の利益（CVR）を予測するモデル用のデータを用意
X_train_treat = train_data[train_data['treat_flg']==1].drop(['cv_flg', 'treat_flg'], axis=1)
Y_train_treat = train_data.loc[train_data['treat_flg']==1, 'cv_flg']

# 介入しない場合の利益（CVR）を予測するモデル用のデータを用意
X_train_control = train_data[train_data['treat_flg']==0].drop(['cv_flg', 'treat_flg'], axis=1)
Y_train_control = train_data.loc[train_data['treat_flg']==0, 'cv_flg']

# ２つのモデルを構築
treat_model = LogisticRegression(C=0.01, random_state=0)
control_model = LogisticRegression(C=0.01, random_state=0)
treat_model.fit(X_train_treat, Y_train_treat)
control_model.fit(X_train_control, Y_train_control)

# 検証データに対して CVR を予測
X_test = test_data.drop(['cv_flg', 'treat_flg'], axis=1)

treat_score = treat_model.predict_proba(X_test)[:, 1]
control_score = control_model.predict_proba(X_test)[:, 1]

# uplift score を算出
uplift_score = treat_score - control_score

• AUUC の算出

# uplift score が大きい順に検証データを並び替え
result = pd.DataFrame(np.c_[test_data['cv_flg'], test_data['treat_flg'], uplift_score], columns=['cv_flg', 'treat_flg', 'uplift_score'])
result = result.sort_values(by='uplift_score', ascending=False).reset_index(drop=True)

# lift の算出
result['treat_num_cumsum'] = result['treat_flg'].cumsum()
result['control_num_cumsum'] = (1 - result['treat_flg']).cumsum()
result['treat_cv_cumsum'] = (result['treat_flg'] * result['cv_flg']).cumsum()
result['control_cv_cumsum'] = ((1 - result['treat_flg']) * result['cv_flg']).cumsum()
result['treat_cvr'] = (result['treat_cv_cumsum'] / result['treat_num_cumsum']).fillna(0)
result['control_cvr'] = (result['control_cv_cumsum'] / result['control_num_cumsum']).fillna(0)
result['lift'] = (result['treat_cvr'] - result['control_cvr']) * result['treat_num_cumsum']
result['base_line'] = result.index * result['lift'][len(result.index) - 1] / len(result.index)

# AUUC の算出
auuc = (result['lift'] - result['base_line']).sum() / len(result['lift'])
print('AUUC = {:.2f}'.format(auuc))
# 出力：=> AUUC = 37.70

• uplift curve の描画

result.plot(y=['lift', 'base_line'])
plt.xlabel('uplift score rank')
plt.ylabel('conversion lift')
plt.show()

• S-Learner の実装

# 学習データの用意（介入有無と特徴量の交互作用項を作成）
X_train = train_data.drop('cv_flg', axis=1)
for feature in ['feature'+str(i) for i in range(8)]:
    X_train['treat_flg_x_' + feature] = X_train['treat_flg'] * X_train[feature]
Y_train = train_data['cv_flg']

# モデルを構築
model = LogisticRegression(C=0.01, random_state=0)
model.fit(X_train, Y_train)

# 介入する場合の検証データの用意
X_test_treat = test_data.drop('cv_flg', axis=1).copy()
X_test_treat['treat_flg'] = 1
for feature in ['feature'+str(i) for i in range(8)]:
    X_test_treat['treat_flg_x_' + feature] = X_test_treat['treat_flg'] * X_test_treat[feature]

# 介入しない場合の検証データの用意
X_test_control = test_data.drop('cv_flg', axis=1).copy()
X_test_control['treat_flg'] = 0
for feature in ['feature'+str(i) for i in range(8)]:
    X_test_control['treat_flg_x_' + feature] = X_test_control['treat_flg'] * X_test_control[feature]

# 検証データに対して利益 CVR を予測
treat_score = model.predict_proba(X_test_treat)[:, 1]
control_score = model.predict_proba(X_test_control)[:, 1]

# uplift score の算出
uplift_score = treat_score - control_score

T-Learner と同様に AUUC を評価したところ、AUUC = 19.60となり、今回のデータでは T-Learner のほうが性能が高いという結果になりました。

おわりに

Uplift modeling の概要と、それを実現するための実装例をまとめました。
誤りなどありましたら編集リクエストをして頂けると幸いです。

参考

• 仕事ではじめる機械学習
• AIアルゴリズムマーケティング 自動化のための機械学習/経済モデル、ベストプラクティス、アーキテクチャ
• uber/causalml: Uplift modeling and causal inference with machine learning algorithm
• A Large Scale Benchmark for Uplift Modeling

Decorator

Decorators are great tools to add additional features to an existing object without using subclassing.

from functools import wraps

def make_blink(function):
    """Defines the decorator"""

    #This makes the decorator transparent in terms of its name and docstring
    @wraps(function)

    #Define the inner function
    def decorator():
        #Grab the return value of the function being decorated
        ret = function() 

        #Add new functionality to the function being decorated
        return "<blink>" + ret + "</blink>"

    return decorator

#Apply the decorator here!
@make_blink
def hello_world():
    """Original function! """

    return "Hello, World!"

#Check the result of decorating
print(hello_world())

#Check if the function name is still the same name of the function being decorated
print(hello_world.__name__)

#Check if the docstring is still the same as that of the function being decorated
print(hello_world.__doc__)

Proxy

Proxy comes in handy when creating an object that is very resource-intensive. It can postpone object creation unless it's absolutely necessary by creating a placeholder.

import time

class Producer:
    """Define the 'resource-intensive' object to instantiate!"""
    def produce(self):
        print("Producer is working hard!")

    def meet(self):
        print("Producer has time to meet you now!")

class Proxy:
    """"Define the 'relatively less resource-intensive' proxy to instantiate as a middleman"""
    def __init__(self):  
        self.occupied = 'No'
        self.producer = None

    def produce(self):
        """Check if Producer is available"""
        print("Artist checking if Producer is available ...")

        if self.occupied == 'No':
            #If the producer is available, create a producer object!
            self.producer = Producer()
            time.sleep(2)

            #Make the prodcuer meet the guest!
            self.producer.meet()

        else:
            #Otherwise, don't instantiate a producer 
            time.sleep(2)
            print("Producer is busy!")

#Instantiate a Proxy
p = Proxy()

#Make the proxy: Artist produce until Producer is available
p.produce()

#Change the state to 'occupied'
p.occupied = 'Yes'

#Make the Producer produce
p.produce()

Adapter

This is used when the interfaces are incompatible between a client and a server.

class Korean:
    """Korean speaker"""
    def __init__(self):
        self.name = "Korean"

    def speak_korean(self):
        return "An-neyong?"

class British:
    """English speaker"""
    def __init__(self):
        self.name = "British"   

    #Note the different method name here!
    def speak_english(self):
        return "Hello!" 

class Adapter:
    """This changes the generic method name to individualized method names"""

    def __init__(self, object, **adapted_method):
        """Change the name of the method"""
        self._object = object

        #Add a new dictionary item that establishes the mapping between the generic method name: speak() and the concrete method
        #For example, speak() will be translated to speak_korean() if the mapping says so
        self.__dict__.update(adapted_method)

    def __getattr__(self, attr):
        """Simply return the rest of attributes!"""
        return getattr(self._object, attr)

#List to store speaker objects
objects = []

#Create a Korean object
korean = Korean()

#Create a British object
british =British()

#Append the objects to the objects list
objects.append(Adapter(korean, speak=korean.speak_korean))
objects.append(Adapter(british, speak=british.speak_english))


for obj in objects:
    print("{} says '{}'\n".format(obj.name, obj.speak()))

Composite

The composite design pattern maintains a tree data structure to represent part-whole relationships. Here we like to build a recursive tree data structure so that an element of the tree can have its own sub-elements.

class Component(object):
    """Abstract class"""

    def __init__(self, *args, **kwargs):
        pass

    def component_function(self):
        pass

class Child(Component): #Inherits from the abstract class, Component
    """Concrete class"""

    def __init__(self, *args, **kwargs):
        Component.__init__(self, *args, **kwargs)

        #This is where we store the name of your child item!
        self.name = args[0]

    def component_function(self):
        #Print the name of your child item here!
        print("{}".format(self.name))

class Composite(Component): #Inherits from the abstract class, Component
    """Concrete class and maintains the tree recursive structure"""

    def __init__(self, *args, **kwargs):
        Component.__init__(self, *args, **kwargs)

        #This is where we store the name of the composite object
        self.name = args[0]

        #This is where we keep our child items
        self.children = []

    def append_child(self, child):
        """Method to add a new child item"""
        self.children.append(child)

    def remove_child(self, child):
        """Method to remove a child item"""
        self.children.remove(child)

    def component_function(self):

        #Print the name of the composite object
        print("{}".format(self.name))

        #Iterate through the child objects and invoke their component function printing their names
        for i in self.children:
            i.component_function()

#Build a composite submenu 1
sub1 = Composite("submenu1")

#Create a new child sub_submenu 11
sub11 = Child("sub_submenu 11")
#Create a new Child sub_submenu 12
sub12 = Child("sub_submenu 12")

#Add the sub_submenu 11 to submenu 1
sub1.append_child(sub11)
#Add the sub_submenu 12 to submenu 1
sub1.append_child(sub12)

#Build a top-level composite menu
top = Composite("top_menu")

#Build a submenu 2 that is not a composite
sub2 = Child("submenu2")

#Add the composite submenu 1 to the top-level composite menu
top.append_child(sub1)

#Add the plain submenu 2 to the top-level composite menu
top.append_child(sub2)

#Let's test if our Composite pattern works!
top.component_function()

Bridge

The bridge pattern helps untangle an unnecessary complicated class hierarchy, especially when implementation specific classes are mixed together with implementation-indendent classes. So our problem here is that there are two parallel or orthogonal abstractions. One is implementation-specific, and the other one is implementation-independent.

class DrawingAPIOne(object):
    """Implementation-specific abstraction: concrete class one"""
    def draw_circle(self, x, y, radius):
        print("API 1 drawing a circle at ({}, {} with radius {}!)".format(x, y, radius))


class DrawingAPITwo(object):
    """Implementation-specific abstraction: concrete class two"""
    def draw_circle(self, x, y, radius):
        print("API 2 drawing a circle at ({}, {} with radius {}!)".format(x, y, radius))

class Circle(object):
    """Implementation-independent abstraction: for example, there could be a rectangle class!"""

    def __init__(self, x, y, radius, drawing_api):
        """Initialize the necessary attributes"""
        self._x = x
        self._y = y
        self._radius = radius
        self._drawing_api = drawing_api

    def draw(self):
        """Implementation-specific abstraction taken care of by another class: DrawingAPI"""
        self._drawing_api.draw_circle(self._x, self._y, self._radius)

    def scale(self, percent):
        """Implementation-independent"""
        self._radius *= percent


#Build the first Circle object using API One
circle1 = Circle(1, 2, 3, DrawingAPIOne())
#Draw a circle
circle1.draw()

#Build the second Circle object using API Two
circle2 = Circle(2, 3, 4, DrawingAPITwo())
#Draw a circle
circle2.draw()

---

More Design Patterns in Python

概要

既存プロジェクトでのパッケージ管理をrequirements.txtで行っていたが、そのパッケージをそのままpoetryでinstallする際のメモ
poetryではrequirements.txtから直接インストールはできない

解決方法

poetry環境ではない場合はまずinitしておく

poetry init

requirements.txtの中身をfor文で回し、一つずつpoetry addしていく

for package in $(cat requirements.txt); do   poetry add "${package}"; done

参考

https://github.com/python-poetry/poetry/issues/46

はじめに

① https://qiita.com/yohiro/items/04984927d0b455700cd1
② https://qiita.com/yohiro/items/5aab5d28aef57ccbb19c
③ https://qiita.com/yohiro/items/cc9bc2631c0306f813b5
④ https://qiita.com/yohiro/items/d376f44fe66831599d0b
⑤ https://qiita.com/yohiro/items/3abaf7b610fbcaa01b9c
の続き

• 参考教材：Udemy みんなのAI講座 ゼロからPythonで学ぶ人工知能と機械学習
• 使用ライブラリ：scikit-learn

課題設定

手書きの数字画像（8×8 px)から、書いてある数字を認識する。

ソースコード

インポート

from sklearn import datasets
from sklearn import svm
from sklearn import metrics
import matplotlib.pyplot as plt

サンプルデータの読み込み

# 数字データの読み込み
digits = datasets.load_digits()

digitsには、以下のようなデータが入っている。

digits.data

[[ 0.  0.  5. ...  0.  0.  0.]
 [ 0.  0.  0. ... 10.  0.  0.]
 [ 0.  0.  0. ... 16.  9.  0.]
 ...
 [ 0.  0.  1. ...  6.  0.  0.]
 [ 0.  0.  2. ... 12.  0.  0.]
 [ 0.  0. 10. ... 12.  1.  0.]]

digits.target

[0 1 2 ... 8 9 8]

digits.dataは64×1797のリストで、要素の値はグレースケールにおける色を表しており、一つの64要素リストが一つの画像を表している。画像表示用にdigits.imageにもリスト形式は異なるが同様の情報が入っている。
digits.targetはそれぞれの画像の正解（=どの数字を表しているか）を示している。

サポートベクターマシンによる訓練

# サポートベクターマシン
clf = svm.SVC(gamma=0.001, C=100.0) # gamma:一つの訓練データが与える影響の大きさ, C:誤認識許容度
# サポートベクターマシンによる訓練(6割のデータを使用、残りの4割は検証用)
clf.fit(digits.data[:int(n*6/10)], digits.target[:int(n*6/10)])

前回使ったのはLinearSVC()だったが、今回はSVC()を使用している。
線形の境界線では分類ができないから？

分類

上記で作成したclfにdigits.dataの残りの4割のデータを読ませ、どの数字になるか、それぞれ分類させる。

# 正解
expected = digits.target[int(-n*4/10):]
# 予測
predicted = clf.predict(digits.data[int(-n*4/10):])
# 正解率
print(metrics.classification_report(expected, predicted))
# 誤認識のマトリックス
print(metrics.confusion_matrix(expected, predicted))

結果

正解率

              precision    recall  f1-score   support

           0       0.99      0.99      0.99        70
           1       0.99      0.96      0.97        73
           2       0.99      0.97      0.98        71
           3       0.97      0.86      0.91        74
           4       0.99      0.96      0.97        74
           5       0.95      0.99      0.97        71
           6       0.99      0.99      0.99        74
           7       0.96      1.00      0.98        72
           8       0.92      1.00      0.96        68
           9       0.96      0.97      0.97        71

    accuracy                           0.97       718
   macro avg       0.97      0.97      0.97       718
weighted avg       0.97      0.97      0.97       718

0と予測したものは99%が正解、正解が0だった内正しく0と予想されたものは99%、のように読む。
表の読み方の参考：
- classification_reportの読み方
- KerasでF1スコアをmetircsに入れる際は要注意

誤認識マトリックス

[[69  0  0  0  1  0  0  0  0  0]
 [ 0 70  1  0  0  0  0  0  2  0]
 [ 1  0 69  1  0  0  0  0  0  0]
 [ 0  0  0 64  0  3  0  3  4  0]
 [ 0  0  0  0 71  0  0  0  0  3]
 [ 0  0  0  0  0 70  1  0  0  0]
 [ 0  1  0  0  0  0 73  0  0  0]
 [ 0  0  0  0  0  0  0 72  0  0]
 [ 0  0  0  0  0  0  0  0 68  0]
 [ 0  0  0  1  0  1  0  0  0 69]]

0の画像の内、0と認識されたものが69件、4と認識されたものが1件、のように読む。

実際の画像と予測値

# 予測と画像の対応（一部）
images = digits.images[int(-n*4/10):]
for i in range(12):
    plt.subplot(3, 4, i + 1)
    plt.axis("off")
    plt.imshow(images[i], cmap=plt.cm.gray_r, interpolation="nearest")
    plt.title("Guess: " + str(predicted[i]))
plt.show()

数字を認識できていることがわかる。

おまけ

digits.dataを可視化してみた(白黒の2値画像)

for i in range(10):
    my_s = ""
    for k, j in enumerate(digits.data[i]):
        if (j > 0):
            my_s += " ■ "
        else:
            my_s += "   "
        if k % 8 == 7:
            print(my_s)
            my_s = ""
    print("\n")

結果

       ■  ■  ■  ■       
       ■  ■  ■  ■  ■    
    ■  ■  ■     ■  ■    
    ■  ■        ■  ■    
    ■  ■        ■  ■    
    ■  ■     ■  ■  ■    
    ■  ■  ■  ■  ■       
       ■  ■  ■          


          ■  ■  ■       
          ■  ■  ■       
       ■  ■  ■  ■       
    ■  ■  ■  ■  ■       
       ■  ■  ■  ■       
       ■  ■  ■  ■       
       ■  ■  ■  ■       
          ■  ■  ■

...

       ■  ■  ■  ■       
       ■  ■  ■  ■       
       ■  ■     ■  ■    
       ■  ■  ■  ■  ■    
       ■  ■  ■  ■       
    ■  ■  ■  ■  ■  ■    
    ■  ■  ■  ■  ■  ■    
       ■  ■  ■  ■  ■    


       ■  ■             
    ■  ■  ■  ■  ■       
    ■  ■  ■  ■  ■       
    ■  ■  ■  ■  ■       
       ■  ■  ■  ■  ■    
          ■     ■  ■    
             ■  ■  ■    
       ■  ■  ■  ■   

なんとなく手書き文字になっていることがわかる

はじめに

前回
おすすめの問題があったらコメントやtwitterでリプ飛して欲しいです。

#29

問題

考えたこと
最初は普通に実装(reverseマシマシ)していましたが、reverseはコストが高いのでうまく処理してあげる必要がある。文字を追加するのは先端か末尾の二つなのでdequeを使うことができる。また、逐一reverseしなくても前後のラベルを作ってreverseのたびに反転させればよい。

from collections import deque

s = deque(input())
q = int(input())
query = [input().split() for _ in range(q)]

reverse = False #前後を判定する
for i in query:
    if len(i) == 1:
        if reverse:
            reverse = False
        else:
            reverse = True
    else:
        if reverse:
            if i[1] == '1':
                s.append(i[2])
            else:
                s.appendleft(i[2]) #先端にappend
        else:
            if i[1] == '1':
                s.appendleft(i[2]) #先端にappend
            else:
                s.append(i[2])
if reverse: #reverseが有効ならsを逆にしなければならない
    s = reversed(s)
    s = ''.join(s)
    print(s)
else:
    s = ''.join(s)
    print(s)

reverseの真偽はもっとうまく処理できると思います。

まとめ

文字列の操作は遅いことを学びました。今回の様に操作する場所が決っている問題は、strよりもlistとかdequeを使った方が良いらしい。ではまた。おやすみなさい。

はじめに

本シリーズでは，確率的プログラミング言語Pyroを用いて統計モデリングを行う方法について，いくつかの例題を交えながら紹介していきます．
例題には，書籍「実践Data Scienceシリーズ RとStanではじめるベイズ統計モデリングによるデータ分析入門」(KS情報科学専門書)に登場する例題を採用します．この本では題名の通りRとStanを用いてベイズモデリングを行っていますが，本シリーズでは同じ例題をPyroを用いて解いていきたいと思います．コーディングを通じて統計モデリングへの理解を深めるとともに，実データにもPyroを用いた柔軟なモデリングを適用できるようになることを目的として執筆します．統計モデリングそのものについての詳しい解説は書籍や他の記事に譲り，本記事では実装をメインに書きます．
読者としては．以下に当てはまるような人を想定しています．

• Pythonの基本的な使い方がわかる人
• ベイズ統計モデリングの基本を理解している人
• 柔軟かつスケーラブルな統計モデリングを行いたい人
• Pytorchユーザ

本記事はそのシリーズの第1回として，Pyroの概要および次回以降のモデリングを実装していく上での基本的なメソッドを説明していきます．

Pyroとは

Pyro はUber AI Labsが開発したPythonで書かれた確率的プログラミング言語の一つです． バックエンドにはPytorchを採用しており，もちろんGPUを利用できます．公式サイトに書いてあることを意訳すると，Pyroを使う利点は以下の通りです．

• 汎用性: あらゆる計算可能な確率分布を表現できる．
• スケーラビリイティ: (並列計算を用いることで)大きなデータセットにも対応可能．
• 最小限: コードの複雑性を可能な限り落としているので挙動を把握しやすい(?)
• 柔軟性: 処理の自動化もできるし，カスタムもできる．
  

特に，GPUを利用可能なフレームワークの特長として，大きなデータセットに対しても実用的な時間で計算できるという利点(=スケーラビリティー)は注目すべきポイントです．他にGPUを利用できる確率的プログラミング言語にはEdward2などがありますが，PytorchユーザにはPyroの方が使いやすいでしょう．

Pyroのインストール

公式リファレンスにある通り，pipを用いて以下のコマンドでインストールできます．

pip install pyro-ppl

Pyroの基本メソッド

Pyroには統計モデリングを実装するための根幹となるメソッドが用意されていますが，その中で最も基本的なpyro.sampleおよびpyro.plateについて本稿で紹介します．これらは，確率分布からのサンプリングを容易に記述できるメソッドです．

1. 確率分布に従うサンプリングpyro.sample

統計モデリングのフレームワークとして欠かせないのが，確率分布に従うサンプリングです． Pyroでは多くの確率分布(正規分布，二項分布，ポアソン分布，...)が用意されており，
pyro.sample(<識別名>, <確率分布>)
という記述により指定した確率分布から標本を抽出することができます．
以下のコードは，標準正規分布から10万個のi.i.dなサンプルを抽出し，確認のために抽出した標本の分布を可視化するものです．

import matplotlib.pyplot as plt
import pyro
import pyro.distributions as dist # distにはPyroで利用できる確率分布が実装されている

# for文でサンプリングを実行
samples = []
for _ in range(100000):
    # 標準正規分布から1つのサンプルを抽出
    a_sample = pyro.sample("a_sample", dist.Normal(0, 1)) # 標準正規分布より
    samples.append(a_sample)

# 可視化
plt.hist(samples, bins=50)
plt.title("標準正規分布からの標本分布(n=10万)", fontsize=16)

適切に標準正規分布からサンプリングされていることが確認できます．
これでも良いのですが，Pyroではよりシンプルな書き方により同様の標本を得ることができます．

2. ベクトルとして取得することを宣言pyro.plate

統計モデリングを行うにあたっては特定の確率分布から多数の独立なサンプルを抽出することは非常に頻繁に行われます．1のようにfor文で記述すると記述・処理の両面において非効率です．
そこで便利なのが，pyro.plateです．
pyro.plate(<コンテクスト名>, <サンプルサイズ>)
によって宣言されたコンテクスト内でpyro.sampleによるサンプリングを行うと，ベクトルとしてサンプルを得られます．以下はその実装です．

# pyro.plateを用いてベクトルとして取得する場合
with pyro.plate("plate", size=100000):
    samples = pyro.sample("samples", dist.Normal(0, 1))

plt.hist(samples, bins=50)
plt.title("標準正規分布からサンプリングした標本分布(n=10万)", fontsize=16)

結果は上図と同様になるはずです．

pyro.sample,pyro.plateを用いることにより，確率分布からサンプリングを行うことができるようになりました．統計モデリングを行うためには他にも不可欠な機能がありますが，それらは次回以降に実例を交えながら随時説明してまいります．

まとめ

本稿では，主に以下の2つの点についての紹介を行いました．
- Pyroの概要や利点
- 確率分布からサンプリングを行うpyro.sample，pyro.plate
冒頭でも述べた通り，次回からは書籍「実践Data Scienceシリーズ RとStanではじめるベイズ統計モデリングによるデータ分析入門」(KS情報科学専門書)に準拠し，書籍で紹介されている例題をPyroで再現する形で進めていきます．
次回は第3部第2章「単回帰モデル」を扱います．

【祝】茶色コーダーになりました〜

12回目でようやく茶色コーダー！！！
一番初めは2重for文も書けなかったのですごい成長！！！
パチパチパチ(拍手)〜

茶色コーダーになるまでにやったこと

競プロ初心者に参考になるかも！
ということでこれまでやってきた事を記事として残しておきます！

①けんちょんさんの記事をいろいろ読んでわくわくする！

一番最初に読んだ記事はこれ！
AtCoder に登録したら次にやること ～ これだけ解けば十分闘える！過去問精選 10 問 ～
まずはこれを一通り見てから、実際にPythonで解いてみました！
ほかにもわくわくする記事は、理解できなくても通勤時間とかに読んでいました！
計算量の記事とか、C問題(300点)レベルがとけるようになるための必須知識！
C++のソースコードは雰囲気で読めばいいと思うよ
とりあえず暇な時に他の人の記事も含めていろいろ読みました！

②とりあえず(ほぼ)毎週夜9時にあるABCに毎回参加する！

＜唐突なラップ＞
一番初めはA問題だけでもACで喜ぶ素人！
でも、他の人の回答を見ると簡潔すぎるソースコード！
そしてそんな書き方があったのか！と、湧き出してくる感動と！
人生にわくわくを与えてくれるAtCoder！ありがと！

・・・

とにかく感動を覚えたソースコードはメモ帳に残して少しずつ自分のものにしていきました！
またレートも毎週のABCでちょっとずつ上がっていくしモチベも維持できました！

③AtCoder Problemsで簡単な問題を解く！

AtCoder Problems
Difficultyが小さいものから解いていって自信をつけていきました！

④AOJのプログラミング入門を解く！

AOJのプログラミング入門
この10トピック(40問)を２周する！
(※トピック11(クラスと構造体)は競プロで使用しないので除外)
入門と言いながらそこそこ歯ごたえがあったw
全てが良問！！！
この40問は非常に勉強になったし、実際、基礎力がしっかり身についた実感がありました！
俺にとってこれはめちゃくちゃ大きかったし自信にもつながった！
2次元配列、3次元配列の恐怖心もなくなりました！
この40問をやれば、まずA,B問題(100、200点)が99%解けるようになります！

⑤武器を1つ1つ身につける。

DP(動的計画法)、キュー/スタック、DFS/BFS、bit全探索・・・
けんちょんさんの記事などを参考に日々勉強。
めちゃくちゃ典型的な基本問題は解けるようにする(現在進行形)。

④と⑤の間くらいで、茶色になることができました！

おまけ タイピングの練習

アルゴリズムの勉強の息抜きににタイピング(寿司打)の練習で遊んでました。
2週間くらい毎日タイピングの練習やってたら、ブラインドタッチができるようになりました〜
ソースコードを書く速度も上がってる気がする→レート上昇に多少はつながってる？？？

次は緑コーダーになれるようにがんばろ！

この記事について

記事タイトルの通りのことがやりたかった。
また使うことがあるかも知れないので、その方法を記録しておく。

手順

• matplotlib で リンク付きのグラフを作成
• svg 形式で保存
• Chrome などのブラウザでファイルを開く

環境

自分は jupyter-lab での作業でした。
バージョンはこんな感じ（pip freeze の結果より）

jupyterlab-server==1.0.7
matplotlib==3.2.1

ファイル作成

# 各種設定
import matplotlib.pyplot as plt
from IPython.display import set_matplotlib_formats

set_matplotlib_formats("svg")

# テストデータ準備
data_list = [[0, 1], [1,0], [1,1]]
label_list = ['google', 'yahoo', 'lightcafe']
url_list = ['https://www.google.com/', 'https://www.yahoo.co.jp/', 'https://www.lightcafe.co.jp/']

# グラフ作成
fig, ax = plt.subplots(1, 1, tight_layout=True)
for d, l, u in zip(data_list, label_list, url_list):
    x, y = d
    ax.scatter(x, y)  #点プロット
    ax.annotate(l, xy=(x, y), size=10,  #文字プロット
                url=u,
                bbox=dict(color='w', alpha=1e-6, url=u),
               )
# 保存
fig.savefig('test.svg')

確認

test.svg を ブラウザで開き、グラフ内のデータ点 or ラベルをクリックすれば
設定したリンクに飛ぶ。

ちなみに、Google Colaboratory で同じものを実行すると svg 保存しなくても、
セルの Output から飛ぶことが出来ました。

以上

参考

• https://stackoverflow.com/a/54121221
• https://matplotlib.org/3.2.1/tutorials/text/annotations.html#advanced-annotations

2020-04-07 作成: windows10/Python-3.8.2-amd64/Django-3.0.4

Django でファイルを汎用クラスビューでアップロードする方法について、
日本語情報は意外と多くありません。
そのため、結構時間がかかってしまいました。
忘れないように記事にしておきます。
この記事は、ファイルのアップロードの原理を手軽に知りたい、という人向きです。

Django を初めて使う人は、こちら。
10 分で終わる Django の実用チュートリアル

前準備

プロジェクト名は mysite、アプリケーション名は fileupload とする。
フォルダ media を mysite/ に作成し、ファイルの保存場所とする。

ここまでのファイルの配置はこうなる。

mysite/
    mysite/
        __pycashe__/    <- 気にしなくていい
        setting.py, urls.py など *.py が 5 個
    fileupload/
        migrations/     <- 気にしなくていい
        models.py, views.py など *.py が 6 個
    media/              <- アップロードしたファイルの保存場所
    manage.py           <- プロジェクトの管理用

Django プロジェクトに、アプリケーション fileupload を登録する。
そのために、settings.py の INSTALLED_APPS に追記。

mysite/mysite/settings.py

INSTALLED_APPS = [
    'fileupload.apps.FileuploadConfig',
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
]

ファイルのアップロード用のディレクトリも登録する。
そのために、settings.py に 2 行を追記。

mysite/mysite/settings.py

MEDIA_ROOT = os.path.join(BASE_DIR, 'media')
MEDIA_URL = '/media/'

url を登録するため urls.py に追記。

mysite/mysite/urls.py

from django.contrib import admin
from django.urls import include, path
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    path('fileupload/', include('fileupload.urls')),
    path('admin/', admin.site.urls),
] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

アプリケーションの実装

モデル Fileupload を作成。
フィールドは、ファイルのタイトルと、ファイルそのものの 2 つ。
ファイルの保存場所は、media/uploads/年/月/日 という名前のフォルダ。
写真をアップロードすることを想定し、拡張子は jpg しか相手にしない。

mysite/fileupload/models.py

from django.db import models
from django.core.validators import FileExtensionValidator

class Fileupload(models.Model):
    titlefield = models.CharField(max_length = 200, null = True)
    filefield = models.FileField(
        upload_to = 'uploads/%Y/%m/%d/',
        verbose_name = 'attached file',
        validators=[FileExtensionValidator(['jpg', ])],
        null = True
    )

ビューを作成する。
Django の汎用クラスビューを使うのは、やっぱり楽だから。
汎用クラスビューは、デフォルトの変数名やファイル名など
（たとえばfileupload_object_name や template_name ）を知っていないと使えない。
だから、デフォルト名ではなく、分かりやすい名前を明示的につけておいた。

mysite/fileupload/views.py

from django.views import generic
from .models import Fileupload

class FileuploadListView(generic.ListView):
    model = Fileupload
    context_object_name = 'fileupload_context_list'

class FileuploadCreateView(generic.CreateView):
    model = Fileupload
    fields = ['titlefield', 'filefield']
    success_url = '/fileupload'
    template_name = 'fileupload/fileupload_create.html'

class FileuploadDetailView(generic.DetailView):
    model = Fileupload
    template_name = 'fileupload/fileupload_detail.html'
    context_object_name = 'fileupload_context'

class FileuploadUpdateView(generic.UpdateView):
    model = Fileupload
    fields = ['titlefield', 'filefield']
    success_url = '/fileupload'
    template_name = 'fileupload/fileupload_update.html'

class FileuploadDeleteView(generic.DeleteView):
    model = Fileupload
    success_url = '/fileupload'
    template_name = 'fileupload/fileupload_delete.html'

ビューを url に登録する。
ファイル fileupload/urls.py を新しく作成。
作成したビューを登録する。

mysite/fileupload/urls.py

from django.urls import path
from . import views

urlpatterns = [
    path('', views.FileuploadListView.as_view()),
    path('index', views.FileuploadListView.as_view(),
        name = 'site_index'),
    path('create', views.FileuploadCreateView.as_view(),
        name = 'site_create'),
    path('detail/<int:pk>', views.FileuploadDetailView.as_view(),
        name = 'site_detail'),
    path('update/<int:pk>', views.FileuploadUpdateView.as_view(),
        name = 'site_update'),
    path('delete/<int:pk>', views.FileuploadDeleteView.as_view(),
        name = 'site_delete'),
]

fileupload/templates/fileupload/にテンプレート用の html ファイルを作成する。
それぞれのビューに対応する。

mysite/fileupload/templates/fileupload/fileupload_list.html

<h1>ファイルの一覧表示</h1>

{% if fileupload_context_list %}
  <table>
  {% for temp in fileupload_context_list %}
    <tr>
      <td><a href = "{% url 'site_detail' temp.pk %}"> {{ temp.titlefield }}</a></td>
      <td>{{ temp.filefield }}</td>
      <td><a href = "{% url 'site_update' temp.pk %}">Edit</a></td>
      <td><a href = "{% url 'site_delete' temp.pk %}">Delete</a></td>
    </tr>
  {% endfor %}
  </table>

{% else %}
<p>No file available.</p>

{% endif %}
<p><a href = "{% url 'site_create' %}">新しいファイルのアップロード</a></p>

mysite/fileupload/templates/fileupload/fileupload_create.html

<h1>ファイルのアップロード</h1>

<form method = "post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ form.titlefield }}
    {{ form.filefield }}
    <input type = "submit" value = "Create" />
</form>

mysite/fileupload/templates/fileupload/fileupload_detail.html

<h1>ファイルの詳細</h1>

{% if fileupload_context %}
  <ul>
    <li>Primary Key Number : {{ fileupload_context.pk }}</li>
    <li>Memo Text : {{ fileupload_context.titlefield }}</li>
    <li>Memo Text : /media/{{ fileupload_context.filefield }}</li>
    <li>File : <img src = /media/{{ fileupload_context.filefield }} /></li>
  </ul>

{% else %}
<p>No file available.</p>

{% endif %}
<p><a href = "{% url 'site_index' %}">ファイルの一覧表示</a></p>

mysite/fileupload/templates/fileupload/fileupload_update.html

<h1>ファイルの更新</h1>

<form method = "post" enctype="multipart/form-data">
    {% csrf_token %}
    {{ form.titlefield }}
    {{ form.filefield }}
    <input type = "submit" value = "Save" />
</form>

mysite/fileupload/templates/fileupload/fileupload_delete.html

<h1>ファイルの削除</h1>

<form method = "post">
    {% csrf_token %}
    <input type= "submit" value = "Delete" />
</form>

仕上げ

マイグレーションを実行し、開発用 www サーバーを起動すれば、
http://localhost:8000/fileupload/ でアクセスできる。

課題

ファイルのアップロードに失敗したときの処理は、ちゃんと書いていないので今後の課題。

おしまい

pythonはまるっきり初心者で、触れたことがほぼないので環境構築からやります！

PythonのVersion確認

Macにはpythonがpreinstallされているのでまずは確認。

$ python --version
Python 2.7.10

$ python3 --version
Python 3.7.7

あるので準備はこれでOK！

なんですが、ない場合や最新のpythonを利用したい場合は別途インストールする必要があります
pyenvをhomebrewでインストールしてpythonを落としていきましょう

Pythonのインストール

$ brew install pyenv

bash_profileなどに環境変数設定などをしたら完了

$ echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile
$ echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bash_profile
$ echo 'eval "$(pyenv init -)"' >> ~/.bash_profile
$ source ~/.bash_profile

インストールできるversionを確認して必要なやつをインストール

$ pyenv install --list

利用できるversionを確認して、インストールしたversionを利用するように pyenv globalを実行
(ここでは3.8.2をインストールします)

$ pyenv install 3.8.2
$ pyenv versions
$ pyenv global 3.8.2
$ python3 --version

これで準備終わり！
もうsample.pyみたいなの作って、python sample.pyで実行できちゃいます！

なんて簡単な環境構築。。

前回より続いて書きます。

リスト型

これまた基本的な
一つの変数に複数のデータを入れる方法です。

リストの基本

直接データを入れることや
下記のように変数として、入れることも可能
また文字列や数値混在でもOK

apple = 4
grape = 'グレープ'
mikan = 6

fruits = [apple, grape, mikan]

print(fruits)
# 出力 [4,グレープ,6]

多重リスト

リストの中にリストを入れる方法です。

rei = [[1.2],[3,4],[5.6]]
# 上記が使い型の例です。


fruits_name_1 = "りんご"
fruits_num_1 = 2
fruits_name_2 = "みかん"
fruits_num_2 = 10

fruits = [[fruits_name_1, fruits_num_1], [fruits_name_2, fruits_num_2]]


print(fruits)
# 出力: [["りんご", 2], ["みかん", 10]]

リストから値を取り出す。

リストにはインデックス(番号)が割り振られています。0から始まり、数値を指定することで取り出せます

最注意事項として一番最後を-1として
-2,-3と順番に取り出せることもできます。

ListSample = [1, 2, 3, 4]
print(ListSample [1]) 
# インデックスが1の「2」が出力される

ListSample = [1, 2, 3, 4]
print(ListSample [-2]) 
# リストの後ろから2番目の「3」が出力される

リストからリストから値を取り出す。

多重リストの取り出しのルールですが。

1,番号: で指定番号より取り出し
2,:番号　で番号一つ手前まで取り出し(-の場合左から数えて手前)
3,番号以上の場合、現状の最後まで

alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(alphabet[1:5]) 
# インデックス1～4までの["b", "c", "d", "e"]が出力される

print(alphabet[:5]) 
# 先頭からインデックス4までの ["a", "b", "c", "d", "e"]が出力される

print(alphabet[6:]) 
# インデックス6から末尾までの ["g", "h", "i", "j"]が出力される

print(alphabet[0:20]) 
# インデックスは9までなので19までという指定では、 
# ["a","b", "c", "d", "e", "f", "g", "h", "i", "j"]と全てが出力される

alphabet = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
print(alphabet[1:-5]) 
# インデックス1～後ろから6番目までの ["b", "c", "d", "e"]が出力される

リストの上書きと追加

ルールとして

• 番号の指定で追加
• appendを使用して最後に追加
• += で最後に追加

alphabet = ["a", "b", "c", "d", "e"]
alphabet[0] = "A" #先頭の要素の値を上書き
print(alphabet) 
# ["A", "b", "c", "d", "e"]が出力される


alphabet = ["a", "b", "c", "d", "e"]
alphabet[1:3] = ["B", "C"] #インデックス１と2にそれぞれ値を代入
print(alphabet) 
# ["a", "B", "C", "d", "e"]が出力される


alphabet = ["a", "b", "c", "d", "e"]
alphabet.append("f") #ひとつだけ追加する場合はappendを使う
print(alphabet) 
# ["a", "b", "c", "d", "e", "f"]が出力される
# なお、 append は、 複数の要素を追加することはできません。 複数の値を追加したい場合には、「+」を使ってリスト同士を連結させます。

alphabet = ["a", "b", "c", "d", "e"]
alphabet += ["f","g"] #複数追加する場合は+を使う
print(alphabet) # ["a", "b", "c", "d", "e", "f", "g"]が出力される

リストから要素の削除

del リスト[インデックス] を使用します。

alphabet = ["a", "b", "c", "d", "e"]
del alphabet[3:] # インデックス3以降の要素を削除
print(alphabet) # ["a", "b", "c"]が出力される
# また、削除の範囲をスライスで指定することも可能です。

alphabet = ["a", "b", "c", "d", "e"]
del alphabet[1:3] # インデックス1～2までの要素を削除
print(alphabet) # ["a", "d", "e"]が出力される

リストのコピー

注意点として
リスト変数にリスト変数を代入するだけだと
同じ内容として認識され、
代入先を変えた場合、代入元も変わってしまいます。

リストの中身だけ変えたい場合
list()を使用します。

```python: 変数そのまま
alphabet = ['a', 'b', 'c']
alphabet_copy = alphabet # alphabet_copyにalphabetの値を代入する
alphabet_copy[0] = 'A' # alphabet_copyの先頭の値を上書きする
print(alphabet_copy)
print(alphabet)

['A', 'b', 'c']
['A', 'b', 'c']
```

```python: list()を使って中身だけ
alphabet = ['a', 'b', 'c']
alphabet_copy = list(alphabet)
alphabet_copy[0] = 'A'
print(alphabet_copy)
print(alphabet)

以下のように出力されます。

['A', 'b', 'c']
['a', 'b', 'c']
```

辞書型

ハッシュとも呼ばれる方法です。
キーとバリューのワンセットで扱われます。

{}を使用するのが注意点です。

city = {"キー1": "バリュー1", "キー2": "バリュー2"}

辞書の取り出し

キーの指定で呼び出します。

dic ={"Japan": "Tokyo", "Korea": "Seoul"}
print(dic["Japan"]) 
# Tokyoと出力される

辞書の上書きと追加

どちらも操作は一緒で
キーを指定して操作します。
指定キーがあれば上書き、なければ追加という形式です。

上書き

dic ={"Japan":"Tokyo","Korea":"Seoul"}
dic["Japan"] = "Osaka"
print(dic) 

# {"Japan": "Osaka", "Korea": "Seoul"}と出力される

追加

dic ={"Japan":"Osaka","Korea":"Seoul"}
dic["China"] = "Beijing"

print(dic) 
# {"Japan": "Osaka", "Korea": "Seoul", "China": "Beijing"}と出力される

辞書の要素の削除

del 辞書名["削除したいキー"]という記述で、指定したキーの要素を削除できます。

削除

dic = {"Japan": "Tokyo", "Korea": "Seoul", "China": "Beijing"}
del dic["China"] 
# 指定した要素を削除
print(dic) 
# {"Japan": "Tokyo", "Korea": "Seoul"}と出力されます。

while文

条件が不成立になるまで行う構文

while 条件式：
条件式がTrueの場合に行われる処理

while

n = 2
while n >0:　# nが0より大きい場合、下記の処理を行う
    print(n)
    n -= 1　# nを-1する

# 出力結果 1 2

whileとif文

合わせ技で、一定の条件まで続けます。

while x != 0:
    # whileの中で実行される処理は、変数xから1を引く処理と引いた後に出力させる処理です。
    x -= 1
    if x != 0:
        print(x)
    else:
        print("Bang")

for文

リストや辞書型など複数データを
変数より取り出す構文

「 for 変数　in リスト: 」で書きます。

nimals = ["tiger", "dog", "elephant"]
for animal in animals: # animalsに含まれる要素の数＝3回処理を繰り返す
    print(animal)
# 出力結果
tiger
dog
elephant

break

繰り返しの終了処理

break

storages = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for n in storages: # storagesに含まれる要素の数=10回処理を繰り返す
    print(n)
    if n >= 5: # nが5以上になった場合、下記の処理を行う
        print("nが5以上になったので処理を終了します")
        break # for文の処理を終了する

continue

処理をスキップしたい場合に使用

continue

storages = [1, 2, 3, 4, 5, 6] # storagesに含まれる要素の数=6回処理を繰り返す
for n in storages:
    if n < 3: #nが3より小さい場合、処理を行わない(スキップする)
        continue
    print(n)

# 出力結果
3
4
5
6

Appendix

enumerate()

for文でindex表示も出したい時使います。

index表示

ist_ = ["a", "b"]
for index, value in enumerate(list_): # listのインデックスと値を取得する
    print(index, value)
# 出力結果
0 a
1 b

多重リストのループ

代入先の変数を用意することで出力できます。

多重リストのループ

list_ = [[1, 2, 3], [4, 5, 6]]
for a, b, c in list_:
    print(a, b, c)
# 出力結果
1 2 3
4 5 6

しかし、元のデータに個数文のデータが無い場合エラーになります。

多重リストのループエラー

list_ = [[1, 2, 3], [4, 5]]
for a, b, c in list_:
    print(a, b, c) # エラーになる
# 出力結果
not enough values to unpack (expected 3, got 2)

辞書型のループ

items()という関数を使うことで
キーとバリューの両方を変数に格納することができます。

辞書形のループ

fruits = {"strawberry": "red", "peach": "pink", "banana": "yellow"}
for fruit, color in fruits.items(): 
# キーはfruitという変数に、バリューはcolorという変数に格納されています
        print(fruit+" is "+color)

# 出力結果
strawberry is red
peach is pink
banana is yellow

背景

• ただ書いてみた

コード

def convert_year_to_wareki(year):
    wareki_start_year = {
        '明治': 1868, '大正': 1912, '昭和': 1926, '平成': 1989, '令和': 2019
    }
    if year < wareki_start_year['大正']:
        return f"(明治{year - wareki_start_year['明治'] + 1}年)"
    elif year == wareki_start_year['大正']:
        return f"(明治{year - wareki_start_year['明治'] + 1}年/大正{year - wareki_start_year['大正'] + 1}年)"
    elif year < wareki_start_year['昭和']:
        return f"(大正{year - wareki_start_year['大正'] + 1}年)"
    elif year == wareki_start_year['昭和']:
        return f"(大正{year - wareki_start_year['大正'] + 1}年/昭和{year - wareki_start_year['昭和'] + 1}年)"
    elif year < wareki_start_year['平成']:
        return f"(昭和{year - wareki_start_year['昭和'] + 1}年)"
    elif year == wareki_start_year['平成']:
        return f"(昭和{year - wareki_start_year['昭和'] + 1}年/平成{year - wareki_start_year['平成'] + 1}年)"
    elif year < wareki_start_year['令和']:
        return f"(平成{year - wareki_start_year['平成'] + 1}年)"
    elif year == wareki_start_year['令和']:
        return f"(平成{year - wareki_start_year['平成'] + 1}年/令和{year - wareki_start_year['令和'] + 1}年)"
    else:
        return f"(令和{year - wareki_start_year['令和'] + 1}年)"

最近Ai教室にお世話になってるので
まとめを書こうと思います。

基礎

出力

言わずしれた出力を。
使われてるクォーテーションはシングルでもダブルでも

print('Hello World')

コメントの入力

# コメント

計算

下記のように計算できます。
使えるのはこのように

・足し算：「＋」
・引き算：「-」　
・掛け算：「＊」
・割り算：「/」
・余りの計算：「%」
・べき乗：「＊＊」

print(3+6)
# 出力結果
9

文字列

クォーテーションで囲むと
文字列となります。

print('3+6')
# 出力結果
3+6

変数

続いて基本となる変数を

変数の基本

n = 3
# nが変数名、3が入れる値
print(n)
# 3と出力
print(n+5)
# 同じように演算でき、8と出力されます。

使えるのは下記の3点

• 半角アルファベット(大文字、小文字)
• 半角数字
• _(アンダースコア)

使えないのは下記のように

• 先頭の文字に数字は使用不可
• 定義されている関数名(printやlistなど)
• 予約語やキーワードと同じ文字列 予約語とは、Pythonのプログラムで使用する文法のようなもので、「if」、「for」、「True」、「False」など33種類あります。

注意点

使えなくもないですが、日本語もOK
しかし定義としてあまり好まれない

動作したあとで判明の場合

下記の形で削除します。

del(変数名)

連結

下記のように連結できます。

n = "田中"
print("名前は" + n + "です")

## 出力: 名前は田中です。

型

文字や数値など型があります。
種類は下記の通り

str型：文字列
int型：整数
float型：浮動小数点

型を知りたい時

print(type(変数名))

age = 17
print(type(age))  # ageの型を知りたい時

# 出力結果
<class 'int'>

型の変換

違う型で連結しとうとすると
エラーが出るので、下記のように変換します。

str() : 文字列に変換
int() : 整数値に変換
float() : 小数点を含む数値型に変換

height = 150
print("身長は" + str(height) + "cmです。")

if文

比較演算子

下記のように書いて、trueかfalsaを返します。

a == b # aとbは等しい
a != b # aはbと等しくない(反転)
a > b # aはbより大きい
a >= b # aはbより大きいまたは等しい
a < b # aはbより小さい
a <= b # aはbより小さいまたは等しい

ifの使用例

if: 左記の条件成立で4インデントされた下記の処理を実行
else: ifとelifが成立しなかったら実行
elif: if,elseの間で別途条件と処理をしたっかたら書く。

基本ifだけでも実行可能
場合によってelseとelifを追加

n = 2
if n == 1: # nが1と等しい場合は下記の処理を行う
    print("これは1番目の処理です。") 
elif n == 2: # nが2と等しい場合は下記の処理を行う
    print("これは2番目の処理です。") 
elif n == 3: # nが3と等しい場合は下記の処理を行う
    print("これは3番目の処理です。") 
else: # 上記の3つの条件式が全て成立しない場合、下記の処理を行う
    print("これは4番目以降の処理です。")

ブール演算子(and・or・not)

条件式A and 条件式B # A、B両方の条件式がTrueの場合、処理を行う
条件式A or 条件式B # A、Bどちらかの条件式がTrueの場合、処理を行う
not 条件式 # 条件式がTrueの時Falseを、Falseの時Trueを返す

使用例

n_1 = 15
n_2 = 29

print(n_1 > 8 and n_1 < 14)
# true

print(not n_1 ** 2 < n_2 * 5)
# true

最近Ai教室にお世話になってるので
まとめを書こうと思います。

基礎

出力

言わずしれた出力を。
使われてるクォーテーションはシングルでもダブルでも

print('Hello World')

コメントの入力

# コメント

計算

下記のように計算できます。
使えるのはこのように

・足し算：「＋」
・引き算：「-」　
・掛け算：「＊」
・割り算：「/」
・余りの計算：「%」
・べき乗：「＊＊」

print(3+6)
# 出力結果
9

文字列

クォーテーションで囲むと
文字列となります。

print('3+6')
# 出力結果
3+6

変数

続いて基本となる変数を

変数の基本

n = 3
# nが変数名、3が入れる値
print(n)
# 3と出力
print(n+5)
# 同じように演算でき、8と出力されます。

使えるのは下記の3点

• 半角アルファベット(大文字、小文字)
• 半角数字
• _(アンダースコア)

使えないのは下記のように

• 先頭の文字に数字は使用不可
• 定義されている関数名(printやlistなど)
• 予約語やキーワードと同じ文字列 予約語とは、Pythonのプログラムで使用する文法のようなもので、「if」、「for」、「True」、「False」など33種類あります。

注意点

使えなくもないですが、日本語もOK
しかし定義としてあまり好まれない

動作したあとで判明の場合

下記の形で削除します。

del 変数名

連結

下記のように連結できます。

n = "田中"
print("名前は" + n + "です")

## 出力: 名前は田中です。

型

文字や数値など型があります。
種類は下記の通り

str型：文字列
int型：整数
float型：浮動小数点

型を知りたい時

print(type(変数名))

age = 17
print(type(age))  # ageの型を知りたい時

# 出力結果
<class 'int'>

型の変換

違う型で連結しとうとすると
エラーが出るので、下記のように変換します。

str() : 文字列に変換
int() : 整数値に変換
float() : 小数点を含む数値型に変換

height = 150
print("身長は" + str(height) + "cmです。")

if文

比較演算子

下記のように書いて、trueかfalsaを返します。

a == b # aとbは等しい
a != b # aはbと等しくない(反転)
a > b # aはbより大きい
a >= b # aはbより大きいまたは等しい
a < b # aはbより小さい
a <= b # aはbより小さいまたは等しい

ifの使用例

if: 左記の条件成立で4インデントされた下記の処理を実行
else: ifとelifが成立しなかったら実行
elif: if,elseの間で別途条件と処理をしたっかたら書く。

基本ifだけでも実行可能
場合によってelseとelifを追加

n = 2
if n == 1: # nが1と等しい場合は下記の処理を行う
    print("これは1番目の処理です。") 
elif n == 2: # nが2と等しい場合は下記の処理を行う
    print("これは2番目の処理です。") 
elif n == 3: # nが3と等しい場合は下記の処理を行う
    print("これは3番目の処理です。") 
else: # 上記の3つの条件式が全て成立しない場合、下記の処理を行う
    print("これは4番目以降の処理です。")

ブール演算子(and・or・not)

条件式A and 条件式B # A、B両方の条件式がTrueの場合、処理を行う
条件式A or 条件式B # A、Bどちらかの条件式がTrueの場合、処理を行う
not 条件式 # 条件式がTrueの時Falseを、Falseの時Trueを返す

使用例

n_1 = 15
n_2 = 29

print(n_1 > 8 and n_1 < 14)
# true

print(not n_1 ** 2 < n_2 * 5)
# true

Factory

Factory is great for:
- Uncertainties in types of objects
- Decisions to be made at runtime regarding what classes to use

class Dog:

    """A simple dog class"""

    def __init__(self, name):
        self._name = name

    def speak(self):
        return "Woof!"

class Cat:

    """A simple dog class"""

    def __init__(self, name):
        self._name = name

    def speak(self):
        return "Meow!"

def get_pet(pet="dog"):

    """The factory method"""

    pets = dict(dog=Dog("Hope"), cat=Cat("Peace"))

    return pets[pet]

d = get_pet("dog")

print(d.speak())

c = get_pet("cat")

print(c.speak())

The attribute name with a single underscore is called a weak private.In the factory function, the mission is really to create these objects and to return these objects to the user of the function.

Abstract Factory

Abstract Factory is great for situations when the user expectation yields multiple related object until runtime.

class Dog:
    """One of the objects to be returned"""

    def speak(self):
        return "Woof!"

    def __str__(self):
        return "Dog"


class DogFactory:
    """Concrete Factory"""

    def get_pet(self):
        """Returns a Dog object"""
        return Dog()

    def get_food(self):
        """Returns a Dog Food object"""
        return "Dog Food!"


class PetStore:
    """ PetStore houses our Abstract Factory """

    def __init__(self, pet_factory=None):
        """ pet_factory is our Abstract Factory """

        self._pet_factory = pet_factory


    def show_pet(self):
        """ Utility method to display the details of the objects retured by the DogFactory """

        pet = self._pet_factory.get_pet()
        pet_food = self._pet_factory.get_food()

        print("Our pet is '{}'!".format(pet))
        print("Our pet says hello by '{}'".format(pet.speak()))
        print("Its food is '{}'!".format(pet_food))


#Create a Concrete Factory
factory = DogFactory()

#Create a pet store housing our Abstract Factory
shop = PetStore(factory)

#Invoke the utility method to show the details of our pet
shop.show_pet()

Here we have one concrete factory(DogFactory), we can definitely create more concrete factories like CatFactory.

Singleton

Singletons are used for:
- only one instance
- Global Variable in an object-oriented way

A Singleton acts as an information cache share by multiple objects. Modules in Python act as Singletons.

class Borg:
    """Borg pattern making the class attributes global"""
    _shared_data = {} # Attribute dictionary

    def __init__(self):
        self.__dict__ = self._shared_data # Make it an attribute dictionary


class Singleton(Borg): #Inherits from the Borg class
    """This class now shares all its attributes among its various instances"""
    #This essenstially makes the singleton objects an object-oriented global variable

    def __init__(self, **kwargs):
        Borg.__init__(self)
        self._shared_data.update(kwargs) # Update the attribute dictionary by inserting a new key-value pair 

    def __str__(self):
        return str(self._shared_data) # Returns the attribute dictionary for printing

#Let's create a singleton object and add our first acronym
x = Singleton(HTTP="Hyper Text Transfer Protocol")
# Print the object
print(x) 

#Let's create another singleton object and if it refers to the same attribute dictionary by adding another acronym.
y = Singleton(SNMP="Simple Network Management Protocol")
# Print the object
print(y)

Builder

Builders are good at solving problems with building a complex object using an excessive number of constructors.

Solution:
Director
Abstract Builder: interfaces
Concrete Builder: implements the interfaces
Product: object being built

class Director():
    """Director"""
    def __init__(self, builder):
        self._builder = builder 

    def construct_car(self):
        self._builder.create_new_car()
        self._builder.add_model()
        self._builder.add_tires()
        self._builder.add_engine()

    def get_car(self):
        return self._builder.car



class Builder():
    """Abstract Builder"""
    def __init__(self):
        self.car = None 

    def create_new_car(self):
        self.car = Car()



class SkyLarkBuilder(Builder):
    """Concrete Builder --> provides parts and tools to work on the parts """

    def add_model(self):
        self.car.model = "Skylark"

    def add_tires(self):
        self.car.tires = "Regular tires"

    def add_engine(self):    
        self.car.engine = "Turbo engine"

class Car():
    """Product"""
    def __init__(self):
        self.model = None
        self.tires = None
        self.engine = None

    def __str__(self):
        return '{} | {} | {}'.format(self.model, self.tires, self.engine)

builder = SkyLarkBuilder()
director = Director(builder)
director.construct_car()
car = director.get_car()
print(car)

Prototype

Prototypes work well in creating multiple identical items.

import copy

class Prototype:

    def __init__(self):
        self._objects = {}

    def register_object(self, name, obj):
        """Register an object"""
        self._objects[name] = obj

    def unregister_object(self, name):
        """Unregister an object"""
        del self._objects[name]

    def clone(self, name, **attr):
        """Clone a registered object and update its attributes"""
        obj = copy.deepcopy(self._objects.get(name))
        obj.__dict__.update(attr)
        return obj

class Car:
    def __init__(self):
        self.name = "Skylark"
        self.color = "Red"
        self.options = "Ex"

    def __str__(self):
        return '{} | {} | {}'.format(self.name, self.color, self.options)

c = Car()
prototype = Prototype()
prototype.register_object('skylark',c)

c1 = prototype.clone('skylark')

print(c1)

---

More Design Patterns in Python

シミュレーションの条件をCSVファイルで保存する方法

OCTAを使用していると、どうしても設定をリスト化して保存したくなります。
毎回gourmetを起動して見るのが手間になるので、一部の設定をCSVファイルで保存できるようにしました。
単純なやり方です。条件を変数にいれて、それをPandasでシリーズにして、データフレームにした後、保存しています。
とりあえずこれを第一弾として、少しずつ改良して良いものにしていこうと思います。

from UDFManager import UDFManager
import pandas as pd
import numpy as np
import os
path = "c:\path"
files = os.listdir(path)
filename = "filename_out.bdf"
openfile = path + '/' + filename
udf = UDFManager(openfile)
print(udf)
#トータルレコードを取得
totRec = udf.totalRecord()
print(totRec)
#読み込んだときの最初のレコード位置はマイナス１
#curRec = udf.currentRecord()
#print(curRec)
#レコード０に飛ぶ
#現在のレコード位置は０になる
#udf.jump(0)
#curRec = udf.currentRecord()
#print(curRec)
#recNum = udf.get('record_data.record_number')

#dynamics_conditions
#time
max_force = udf.get('Simulation_Conditions.Dynamics_Conditions.Max_Force')
delta_t = udf.get('Simulation_Conditions.Dynamics_Conditions.Time.delta_T')
total_steps = udf.get('Simulation_Conditions.Dynamics_Conditions.Time.Total_Steps')
output_interval_steps = udf.get('Simulation_Conditions.Dynamics_Conditions.Time.Output_Interval_Steps')

time_list = (max_force,delta_t,total_steps,output_interval_steps)
time_list_s = pd.Series(time_list, index=['Max_Force', 'Time.delta_T', 'Time.Total_Steps','Time.Output_Interval_Steps'])

#temp
temperature = udf.get('Simulation_Conditions.Dynamics_Conditions.Temperature.Temperature')
interval_of_scale_temp = udf.get('Simulation_Conditions.Dynamics_Conditions.Temperature.Interval_of_Scale_Temp')

temp_list = (temperature,interval_of_scale_temp)
temp_list_s = pd.Series(temp_list,index=['Temperature','Temperature.Interval_of_Scale_Temp'])


#pressure
pressure = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Pressure')
stress_xx = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.xx')
stress_yy = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.yy')
stress_zz = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.zz')
stress_yz = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.yz')
stress_zx = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.zx')
stress_xy = udf.get('Simulation_Conditions.Dynamics_Conditions.Pressure_Stress.Stress.xy')

stress_list = (pressure,stress_xx,stress_yy,stress_zz,stress_yz,stress_zx,stress_xy)
stress_list_s = pd.Series(stress_list,index=['Pressure','Stress.xx','Stress.yy','Stress.zz','Stress.yz','Stress.zx','Stress.xy'])

#solver
solver_type = udf.get('Simulation_Conditions.Solver.Solver_Type')
dynamics_algorithm = udf.get('Simulation_Conditions.Solver.Dynamics.Dynamics_Algorithm')

solver_list = (solver_type,dynamics_algorithm)
solver_list_s = pd.Series(solver_list,index=['Solver_Type','Dynamics_Algorithm'])

#Boundary_Conditions
boundary_conditions_a_axis = udf.get('Simulation_Conditions.Boundary_Conditions.a_axis')
boundary_conditions_b_axis = udf.get('Simulation_Conditions.Boundary_Conditions.b_axis')
boundary_conditions_c_axis = udf.get('Simulation_Conditions.Boundary_Conditions.c_axis')
boundary_conditions_periodic_bond = udf.get('Simulation_Conditions.Boundary_Conditions.Periodic_Bond')

boundary_conditions_list = (boundary_conditions_a_axis,boundary_conditions_b_axis,boundary_conditions_c_axis,boundary_conditions_periodic_bond)
boundary_conditions_list_s = pd.Series(boundary_conditions_list,index=['a_axis','b_axis','c_axis','Periodic_Bond'])


#Calc_Potential_Flags.Bond
calc_potential_flags_bond = udf.get('Simulation_Conditions.Calc_Potential_Flags.Bond')
calc_potential_flags_angle = udf.get('Simulation_Conditions.Calc_Potential_Flags.Angle')
calc_potential_flags_torsion = udf.get('Simulation_Conditions.Calc_Potential_Flags.Torsion')
calc_potential_flags_non_bonding_interchain = udf.get('Simulation_Conditions.Calc_Potential_Flags.Non_Bonding_Interchain')
calc_potential_flags_non_bonding_intrachain = udf.get('Simulation_Conditions.Calc_Potential_Flags.Non_Bonding_Intrachain')
calc_potential_flags_non_bonding_1_3 = udf.get('Simulation_Conditions.Calc_Potential_Flags.Non_Bonding_1_3')
calc_potential_flags_non_bonding_1_4 = udf.get('Simulation_Conditions.Calc_Potential_Flags.Non_Bonding_1_4')
calc_potential_flags_external = udf.get('Simulation_Conditions.Calc_Potential_Flags.External')
calc_potential_flags_electrostatic = udf.get('Simulation_Conditions.Calc_Potential_Flags.Electrostatic')
calc_potential_flags_tail_correction = udf.get('Simulation_Conditions.Calc_Potential_Flags.Tail_Correction')

calc_potential_list = (calc_potential_flags_bond, calc_potential_flags_angle,calc_potential_flags_torsion,
                                calc_potential_flags_non_bonding_interchain,calc_potential_flags_non_bonding_intrachain,calc_potential_flags_non_bonding_1_3,
                                calc_potential_flags_non_bonding_1_4,calc_potential_flags_external,calc_potential_flags_electrostatic,calc_potential_flags_tail_correction)

calc_potential_list_s = pd.Series(calc_potential_list,index=['Bond','Angle','Torsion','Non_Bonding_Interchain','Non_Bonding_Intrachain','Non_Bonding_1_3',
                                'Non_Bonding_1_4','External','Electrostatic','Tail_Correction'])

#Output_Flags_is_no_count
#Initial_Structure
initial_unit_cell_density = udf.get('Initial_Structure.Initial_Unit_Cell.Density')
initial_unit_cell_cell_size_a = udf.get('Initial_Structure.Initial_Unit_Cell.Cell_Size.a')
initial_unit_cell_cell_size_b = udf.get('Initial_Structure.Initial_Unit_Cell.Cell_Size.b')
initial_unit_cell_cell_size_c = udf.get('Initial_Structure.Initial_Unit_Cell.Cell_Size.c')
initial_unit_cell_cell_size_alpha = udf.get('Initial_Structure.Initial_Unit_Cell.Cell_Size.alpha')
initial_unit_cell_cell_size_beta = udf.get('Initial_Structure.Initial_Unit_Cell.Cell_Size.beta')
initial_unit_cell_shear_strain = udf.get('Initial_Structure.Initial_Unit_Cell.Shear_Strain')
initial_unit_cell_density = udf.get('Initial_Structure.Initial_Unit_Cell.Density')

initial_unit_cell_list = (initial_unit_cell_density, initial_unit_cell_cell_size_a,initial_unit_cell_cell_size_b,
                                initial_unit_cell_cell_size_c ,initial_unit_cell_cell_size_alpha,initial_unit_cell_cell_size_beta,
                                initial_unit_cell_shear_strain,initial_unit_cell_density)

initial_unit_cell_list_s = pd.Series(initial_unit_cell_list,index=['Density','Cell_Size.a','Cell_Size.b','Cell_Size.c','Cell_Size.alpha','Cell_Size.beta',
                                'Shear_Strain','Density'])

#generated_method
generate_method_method= udf.get('Initial_Structure.Generate_Method.Method')
relaxation= udf.get('Initial_Structure.Relaxation.Relaxation')
relaxation_method= udf.get('Initial_Structure.Relaxation.Method')

generated_method_list = (generate_method_method, relaxation,relaxation_method)

generated_method_list_s = pd.Series(generated_method_list,index=['Method','Relaxation','Relaxation.Method'])

octa_pd = pd.concat([time_list_s, temp_list_s,stress_list_s,solver_list_s, boundary_conditions_list_s, calc_potential_list_s,initial_unit_cell_list_s,generated_method_list_s],axis=0)

savefile = path + '/' + filename + 'setteing_info.csv'

octa_pd.to_csv(savefile)

こんにちは。

IQ Botのカスタムロジックは結局はPythonなので、Pythonが書ける人は難なく扱えるはずです。

そしてPythonはJavaやCなどのプログラミング言語に比べれば、初心者が入りやすい言語だと言われています。

JavaやCなど他のプログラミング言語をやっていた人は、
ゼロから始める人よりは早くPythonをマスターできると思いますが、

他の言語をやっていたがゆえに「えっ？　そんなのあり？」とびっくりするポイントもあるかもしれません。

この記事では、他言語を扱っていた人ならではのPythonびっくりポイントをまとめてみます。

コンパイルがいらない

Pythonは動的言語なので、動かすにあたってコンパイルが要りません。

なのでIQ Botのカスタムロジックも、コンパイルとか気にすることなく、
書いたら即座に「Test Run」を押せばその場で動きます。

動的言語についての説明はWikipediaにまとまっていたのでそちらをご参照ください。

型を宣言しないで変数を使える

Pythonは型付けを動的に行っているので、変数の型を宣言する必要がありません。

Javaの場合、以下のようなコードを書くと、
２行目で怒られてコンパイルエラーになります。

javaの場合

int num = 3;       // ここで変数numの型を宣言！
num = "やっほー";   // こういうことすると怒られます

int型、つまり「整数しか入らないよ」って言ってる箱（＝numという変数）に、
"やっほー"などというふざけた文字列（String型）を突っ込もうとしたからですね。

あ、すみません、問題は「型が違う」という点なので、文字列の中身がまじめでも怒られます。

一方、Pythonの場合は以下のようなコードでも全然問題なく動きます。

Pythonの場合

num = 3           #こうすれば変数numは勝手にint型になる  
num = "やっほー"   #ここで変数numは勝手にString型に変身する……！！

この特徴は、筆者のような雑な性格の人間にとっては非常にありがたいんですが、
他のプログラミング言語のお行儀のいいコーディングに慣れている人からすると、

「変数の型が途中で変わる」というのはけっこうびっくりする話かもしれません。

Pythonでも型という概念自体がなくなっているわけではなく、
あくまで型付けをプログラミング言語側で動的にやってくれる機能があるというだけです。

Pythonの型の一覧や、型の確認方法、キャスト（型変換）のしかたなどは
こちらのページに非常にわかりやすくまとまっていました。

IQ Botにカスタムロジックをかける際も、型のキャストは時々使います。

インデントに実行上の意味がある

他の言語の場合、if文や関数の中でインデントを揃えるのはあくまでも
「人間にとっての可読性向上のためのベストプラクティス」であって、

インデントにはプログラムを実行する上での意味は持たせていないという仕様が一般的です。

つまり以下のように、インデントが汚くてもプログラムは問題なく動く、という言語がほとんどです。

javaの場合①：こう書いた方がきれいだけど……

class xxx
{
  public static void main (String[] args) throws java.lang.Exception
  {
    int num = 3;
    if (num % 2 == 0) 
    {
      System.out.println(num + "は、偶数です");
    }
    else {
      System.out.println(num + "は、奇数です");
    }
  }
}

javaの場合②：これでも動くことは動く。

class xxx
{
public static void main (String[] args) throws java.lang.Exception
{
int num = 3;
if (num % 2 == 0) 
{
System.out.println(num + "は、偶数です");
}
else {
System.out.println(num + "は、奇数です");
}
}
}

一方、Pythonは「すべてのプログラマーがすべからく可読性の高いコードを書くことを保証するように」という思想に基づき、
インデントを揃えないとそもそもコードが動かないようになっています。

Pythonの場合①：こう書けば動くけど……

num = 3
if num % 2 == 0:
    print(str(num) + "は、偶数です")
else:
    print(str(num) + "は、奇数です")

Pythonの場合②：これだと動かない

num = 3
if num % 2 == 0:
print(str(num) + "は、偶数です")
else:
print(str(num) + "は、奇数です")

インデントが正しくそろってないと、基本的には「IndentationError」というエラーが出ます。

こちらの記事のように、インデントのレベルが正しくいないがゆえに、
想定と違う結果が出てしまうケースもあるので注意しましょう！

ループが楽

PythonとJavaのループ処理をわかりやすくまとめた記事があったので、
そちらを紹介しておきます。

JavaとPythonの基礎文法比較

ループ処理以外の文法も色々まとまっているので参考にしてみてください。

文字列を配列みたいに扱える

Javaなどの言語をもともとやっていた人からすると、
上記のリンクにあった以下のコードを見ると、けっこうびっくりするかもしれません。

Pythonではわりと一般的なループ

for char in 'Hello':
    print(char)

上記の処理をやると、以下の結果が返ってくるんですが……

上記ループの処理結果

>>>H
>>>e
>>>l
>>>l
>>>o

なぜこんなことができるのかというと、Pythonでは文字列を、
ひとつひとつの文字を要素として持つシーケンスとして扱うという発想があるからです。

なので、Javaみたいにまず配列に分けて、それからループを回して、みたいなことをする必要がなくて、
文字列をそのままループやスライス（文字列の何番目から何番目を取得するような処理）にかけることができます。

スライスはIQ Botのカスタムロジックでも意外と（？）使うので、
わかりやすかった記事をリンクしておきます。

【Python】スライス操作についてまとめ

まとめ

いかがでしたか？

他言語をやっていた人ならびっくりするかもしれないPythonのポイントは、まとめると以下のとおりです。

• Pythonは動的言語なのでコンパイルが要らないよ
• Pythonは動的型付けができるので変数の型を宣言する必要がないよ（型という概念はあるのでキャストはできるよ）
• インデントを揃えないと怒られて実行できないよ
• ループの書き方がJavaとはけっこう違うかも
• 文字列を配列みたいに扱って直接ループにかけたりスライスしたりできるよ

他にも発見したら追記します。

それでは！

こんにちは。

IQ Botのカスタムロジックは結局はPythonなので、Pythonが書ける人は難なく扱えるはずです。

そしてPythonはJavaやCなどのプログラミング言語に比べれば、初心者が入りやすい言語だと言われています。

JavaやCなど他のプログラミング言語をやっていた人は、
ゼロから始める人よりは早くPythonをマスターできると思いますが、

他の言語をやっていたがゆえに「えっ？　そんなのあり？」とびっくりするポイントもあるかもしれません。

この記事では、他言語を扱っていた人ならではのPythonびっくりポイントをまとめてみます。

コンパイルがいらない

Pythonは動的言語なので、動かすにあたってコンパイルが要りません。

なのでIQ Botのカスタムロジックも、コンパイルとか気にすることなく、
書いたら即座に「Test Run」を押せばその場で動きます。

動的言語についての説明はWikipediaにまとまっていたのでそちらをご参照ください。

型を宣言しないで変数を使える

Pythonは型付けを動的に行っているので、変数の型を宣言する必要がありません。

Javaの場合、以下のようなコードを書くと、
２行目で怒られてコンパイルエラーになります。

javaの場合

int num = 3;       // ここで変数numの型を宣言！
num = "やっほー";   // こういうことすると怒られます

int型、つまり「整数しか入らないよ」って言ってる箱（＝numという変数）に、
"やっほー"などというふざけた文字列（String型）を突っ込もうとしたからですね。

あ、すみません、問題は「型が違う」という点なので、文字列の中身がまじめでも怒られます。

一方、Pythonの場合は以下のようなコードでも全然問題なく動きます。

Pythonの場合

num = 3           #こうすれば変数numは勝手にint型になる  
num = "やっほー"   #ここで変数numは勝手にString型に変身する……！！

この特徴は、筆者のような雑な性格の人間にとっては非常にありがたいんですが、
他のプログラミング言語のお行儀のいいコーディングに慣れている人からすると、

「変数の型が途中で変わる」というのはけっこうびっくりする話かもしれません。

Pythonでも型という概念自体がなくなっているわけではなく、
あくまで型付けをプログラミング言語側で動的にやってくれる機能があるというだけです。

Pythonの型の一覧や、型の確認方法、キャスト（型変換）のしかたなどは
こちらのページに非常にわかりやすくまとまっていました。

IQ Botにカスタムロジックをかける際も、型のキャストは時々使います。

インデントに実行上の意味がある

他の言語の場合、if文や関数の中でインデントを揃えるのはあくまでも
「人間にとっての可読性向上のためのベストプラクティス」であって、

インデントにはプログラムを実行する上での意味は持たせていないという仕様が一般的です。

つまり以下のように、インデントが汚くてもプログラムは問題なく動く、という言語がほとんどです。

javaの場合①：こう書いた方がきれいだけど……

class xxx
{
  public static void main (String[] args) throws java.lang.Exception
  {
    int num = 3;
    if (num % 2 == 0) 
    {
      System.out.println(num + "は、偶数です");
    }
    else {
      System.out.println(num + "は、奇数です");
    }
  }
}

javaの場合②：これでも動くことは動く。

class xxx
{
public static void main (String[] args) throws java.lang.Exception
{
int num = 3;
if (num % 2 == 0) 
{
System.out.println(num + "は、偶数です");
}
else {
System.out.println(num + "は、奇数です");
}
}
}

一方、Pythonは「すべてのプログラマーがすべからく可読性の高いコードを書くことを保証するように」という思想に基づき、
インデントを揃えないとそもそもコードが動かないようになっています。

Pythonの場合①：こう書けば動くけど……

num = 3
if num % 2 == 0:
    print(str(num) + "は、偶数です")
else:
    print(str(num) + "は、奇数です")

Pythonの場合②：これだと動かない

num = 3
if num % 2 == 0:
print(str(num) + "は、偶数です")
else:
print(str(num) + "は、奇数です")

インデントが正しくそろってないと、基本的には「IndentationError」というエラーが出ます。

こちらの記事のように、インデントのレベルが正しくいないがゆえに、
想定と違う結果が出てしまうケースもあるので注意しましょう！

ループが楽

PythonとJavaのループ処理をわかりやすくまとめた記事があったので、
そちらを紹介しておきます。

JavaとPythonの基礎文法比較

ループ処理以外の文法も色々まとまっているので参考にしてみてください。

文字列を配列みたいに扱える

Javaなどの言語をもともとやっていた人からすると、
上記のリンクにあった以下のコードを見ると、けっこうびっくりするかもしれません。

Pythonではわりと一般的なループ

for char in 'Hello':
    print(char)

上記の処理をやると、以下の結果が返ってくるんですが……

上記ループの処理結果

>>>H
>>>e
>>>l
>>>l
>>>o

なぜこんなことができるのかというと、Pythonでは文字列を、
ひとつひとつの文字を要素として持つシーケンスとして扱うという発想があるからです。

なので、Javaみたいにまず配列に分けて、それからループを回して、みたいなことをする必要がなくて、
文字列をそのままループやスライス（文字列の何番目から何番目を取得するような処理）にかけることができます。

スライスはIQ Botのカスタムロジックでも意外と（？）使うので、
わかりやすかった記事をリンクしておきます。

【Python】スライス操作についてまとめ

まとめ

いかがでしたか？

他言語をやっていた人ならびっくりするかもしれないPythonのポイントは、まとめると以下のとおりです。

• Pythonは動的言語なのでコンパイルが要らないよ
• Pythonは動的型付けができるので変数の型を宣言する必要がないよ（型という概念はあるのでキャストはできるよ）
• インデントを揃えないと怒られて実行できないよ
• ループの書き方がJavaとはけっこう違うかも
• 文字列を配列みたいに扱って直接ループにかけたりスライスしたりできるよ

他にも発見したら追記します。

それでは！

動機

• ネタ探しをしていて、Qiita.com:個人でも使える！おすすめAPI一覧の投稿に出会う。
• コメント欄に「NHK 番組表 APIもいいよ」とあったので覗いて見たら簡単そうだった。
• REST APIから取得(JSON形式)して、加工・整形してHTML作成まではいい練習と思い。
• NHK番組APIを使ってオリジナルの番組表を作って見ました。(見てくれは残念ですが、、、)

API keyの取得の流れ

1. NHK番組APIで、アカウント登録を行います。
2. メール認証を経て、アプリケーション名：（好きな名称）、URL：（未登録）を登録します。
3. 登録が完了するとAPI キーが発行されます。これが取得に必要です。

APIの概要

• 公開中のAPIは以下の４種類になります。

No.	名称	説明
1	Program List API	地域、サービス、日付を指定
2	Program Genre API	地域、ジャンル、日付を指定
3	Program Info API	番組IDを指定
4	Now On Air API	地域、サービスを指定

• 今回利用するProgram List APIは以下の構成になっています。

https://api.nhk.or.jp/v2/pg/list/{area}/{service}/{date}.json?key={apikey}

パラメータ	説明	値
area	地域ID(3byte)	130:東京,他46地域
service	サービスID(2byte)	g1：NHK総合,e1:Eテレ,s1:BS,s3:BSP
date	日付(YYYY-MM-DD形式)	例:2020-04-07
apikey	APIキー(32byte)	アプリ登録で取得したAPIキー

• レスポンスフォーマットは、jsonで、利用回数制限は300回/日となっています。
• 以下の例は、area:130(東京)、service:g1(NHK総合)、date:2020-04-07で取得した一部です。

{
  "list": {
    "g1": [
      {
        "id": "2020040704706",
        "event_id": "04706",
        "start_time": "2020-04-07T04:02:00+09:00",
        "end_time": "2020-04-07T04:30:00+09:00",
        "area": {
          "id": "130",
          "name": "東京"
        },
        "service": {
          "id": "g1",
          "name": "ＮＨＫ総合１",
          "logo_s": {
            "url": "//www.nhk.or.jp/common/img/media/gtv-100x50.png",
            "width": "100",
            "height": "50"
          },
          "logo_m": {
            "url": "//www.nhk.or.jp/common/img/media/gtv-200x100.png",
            "width": "200",
            "height": "100"
          },
          "logo_l": {
            "url": "//www.nhk.or.jp/common/img/media/gtv-200x200.png",
            "width": "200",
            "height": "200"
          }
        },
        "title": "ダーウィンが来た！「波乱のライオン学園に潜入！百獣の王を養成！！」",
        "subtitle": "成長まっただ中のライオンの子どもたちが、群れの中で先生役の大人から狩りの技や子育て術を学ぶ。不真面目な生徒は退学処分に！？学園ドラマ顔負けの波乱の日々に密着！",
        "content": "新年度１本目は、ライオンの「学校」をご紹介。成長真っ最中のライオンの子どもたちが、群れの中で先生役の大人から狩りや子育て、ライバル撃退法まで、生きるためのあらゆるスベを学ぶ。でもライバル・ハイエナに全く歯が立たなかったり、狩りでは姿が丸見えで獲物にあっさり逃げられたり、実践形式の授業にみんなタジタジ。さらに不真面目な生徒はまさかの退学処分に！？学園ドラマ顔負けの波乱の授業に潜入！歌：ＭＩＳＩＡ",
        "act": "【語り】和久田麻由子，龍田直樹，豊嶋真千子，山田孝之，水瀬いのり",
        "genres": [
          "0802",
          "1000"
        ]
      },
{以下、省略}

データ取得

• 取得したAPIキーで、Program List APIを叩く。
• 取得サービスは、g1:総合１、e1:Eテレ、s1:BS1、s3:BSプレミアムの４局です。
• pandasのjson_normalize()を使って、json形式をデータフレームに変換します。

import pandas as pd
import json
import requests
import datetime

# 取得したAPIキーをセット
apikey = 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'

# 130:東京
area = '130'
# g1:NHK総合１,e1:Eテレ,s1:BS,s3:BSP
service = ['g1','e1','s1','s3']
# 日時
date = datetime.date.today()

all_results = pd.DataFrame(index=None, columns=[])
for i in range(len(service)):
    url = 'https://api.nhk.or.jp/v2/pg/list/{0}/{1}/{2}.json?key={3}'.format(area,service[i],date,apikey)
    request_get = requests.get(url)
    if request_get.status_code != 200:
        print('NHK番組表APIのデータが取得出来ません。')
        break
    result = pd.json_normalize(request_get.json(), ['list',[service[i]]])
    all_results = pd.concat([all_results, result])

all_results = all_results[~all_results['title'].str.contains('放送休止')]

取得したデータ概要：

<class 'pandas.core.frame.DataFrame'>
Int64Index: 235 entries, 0 to 37
Data columns (total 22 columns):
 #   Column                 Non-Null Count  Dtype 
---  ------                 --------------  ----- 
 0   id                     235 non-null    object
 1   event_id               235 non-null    object
 2   start_time             235 non-null    object
 3   end_time               235 non-null    object
 4   title                  235 non-null    object
 5   subtitle               235 non-null    object
 6   content                235 non-null    object
 7   act                    235 non-null    object
 8   genres                 235 non-null    object
 9   area.id                235 non-null    object
 10  area.name              235 non-null    object
 11  service.id             235 non-null    object
 12  service.name           235 non-null    object
 13  service.logo_s.url     235 non-null    object
 14  service.logo_s.width   235 non-null    object
 15  service.logo_s.height  235 non-null    object
 16  service.logo_m.url     235 non-null    object
 17  service.logo_m.width   235 non-null    object
 18  service.logo_m.height  235 non-null    object
 19  service.logo_l.url     235 non-null    object
 20  service.logo_l.width   235 non-null    object
 21  service.logo_l.height  235 non-null    object
dtypes: object(22)
memory usage: 42.2+ KB

データ加工

• 日付形式に置き換え、放送時間の算出、ページ内リンクのためのHTMLコード列の追加

# 日付形式に変換、放送時間の計算
all_results['start_time'] = pd.to_datetime(all_results['start_time'], format='%Y/%m/%d %H:%M')
all_results['end_time'] = pd.to_datetime(all_results['end_time'], format='%Y/%m/%d %H:%M')
all_results['airtime'] = all_results['end_time'] - all_results['start_time']
all_results['link'] = all_results['id']
# ページ内リンク情報の作成
func = lambda x: x.replace(x, f'<div id="{x}">番組詳細</div>')
all_results['link'] = all_results['link'].apply(func)

# 月・日。時間・分を取得する。さらに番組表の時間行名を追加する
tmp = pd.concat([all_results['start_time'].dt.month ,all_results['start_time'].dt.day,
                 all_results['start_time'].dt.hour, all_results['start_time'].dt.minute,
                 (all_results['start_time'].dt.day.astype(str)+all_results['start_time'].dt.strftime('%H'))], axis=1)
tmp.columns = ['month', 'day', 'hour', 'minute','time_bins']

# 取得データと新規の列を結合する
all_results = pd.concat([all_results, tmp], axis=1)

# 番組表ための集約
data = all_results.iloc[:,[23,0,1,2,3,4,5,6,7,8,9,10,11,12,22,24,25,26,27,28]]

データ整形(その１)

• 番組表の必要データが揃えられたので、最終形のテーブルを作成してHTML形式保存します。

# 最終の番組表のデータフレーム作成
tv_index = data.time_bins.sort_values().unique()
tv_table = pd.DataFrame(index=tv_index, columns=['H', 'g1', 'e1', 's1', 's3']).fillna('')

# コンテンツを結合して時間帯に挿入する。
cell = ''
for s in range(len(service)):
    for i in range(len(tv_table.index)):
        tmp = data[(data['time_bins'] == tv_table.index[i]) & (data['service.id'] == service[s])]

        for c in range(len(tmp)):
            cell += '[' + str(tmp['minute'].iloc[c]) + '~]'
            cell += tmp['title'].iloc[c]
            cell += f'<a href="#{tmp["id"].iloc[c]}">▼</a><br>'
        tv_table[service[s]].iloc[i] = cell
        cell = ''

# 時間帯追加
for h in range(len(tv_index)):
    tv_table['H'].iloc[h] = int(tv_index[h][-2:])
tv_table.columns = ['H', 'NHK総合', 'Eテレ', 'BS', 'BSP']

データ整形(その２)

• 番組タイトルから、ページ内リンクとして番組詳細情報を提供するためテーブル作成します。

detail_table = data.stack().reset_index()
detail_table.drop(columns='level_0', inplace=True)
detail_table.columns = ['種別', '値']
detail_table.set_index('種別', drop=True, inplace=True)

データ整形(その3)

• pandasのto_htmlを使って、htmlファイルを作成します。

• htmlファイルの定義情報

html_template = '''
<!doctype html>
<html lang="ja">
  <head>
    <!-- Required meta tags -->
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">

    <!-- Bootstrap CSS -->
    <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css" integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
    <title>私製番組表</title>　<!-- #1 -->
  </head>
  <body>
    <h2>&nbsp;NHK番組表APIを使ってオリジナル番組表を作って見ました。{date}版</h2>　<!-- #2 -->

    <!-- Optional JavaScript -->
    <!-- jQuery first, then Popper.js, then Bootstrap JS -->
    <script src="https://code.jquery.com/jquery-3.4.1.slim.min.js" integrity="sha384-J6qa4849blE2+poT4WnyKhv5vZF5SrPo0iEjwBvKU7imGFAV0wwj1yYfoRSJoZ+n" crossorigin="anonymous"></script>
    <script src="https://cdn.jsdelivr.net/npm/popper.js@1.16.0/dist/umd/popper.min.js" integrity="sha384-Q6E9RHvbIyZFJoft+2mJbHaEWldlvI9IOYy5n3zV9zzTtmI3UksdQRVvoxMfooAo" crossorigin="anonymous"></script>
    <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/js/bootstrap.min.js" integrity="sha384-wfSDF2E50Y2D1uUdj0O3uMBJnjuUD4Ih7YwaYd1iqfktj0Uod8GCExl3Og8ifwB6" crossorigin="anonymous"></script>
    <style type="text/css"> th {{ text-align: center; background-color: #f5f5f5}}</style>
    <div class="container-fluid"> <!-- #3 -->
        {table}
    </div>
    <div class="container-fluid"> <!-- #4 -->
        {table1}
    </div>
    <div>情報提供:ＮＨＫ</div> <!-- #5 -->
</body>
</html>

定義情報に追加したの以下の内容になります。
1. title:ページタイトル
2. h2:見出し + {date}
3. ４局の番組表table {table} -> table
4. 番組詳細table {table1} -> table1
5. クレジット表示

• htmlファイル形式の保存

table = tv_table.to_html(classes=['table', 'table-bordered', 'table-hover'],escape=False)
table1 = detail_table.to_html(classes=['table', 'table-bordered', 'table-hover'],escape=False)
html = html_template.format(table=table, table1=table1, date=date)

with open('g1_table_' + str(date) + '.html', 'w') as f:
    f.write(html)

▼をクリックすると、ページ内リンクで番組詳細データにスクロールします。

参考サイト

• pandasのDataFrameを元に、画像入りの表をつくる
• 上記のサイト情報から bootstrapのバージョンを最新化しました。

まとめ

• pandas.read_jsonとpandas.to_htmlがどこまで使えるか確認したかったので、練習としては最適だった。
• pandas.read_jsonは軽い入り口的な状態で終わったので、また材料を探そうと思う。
• pandas.to_htmlは、そもそもの使い方が理解できたのが収穫でした。
• ただBootstrapを導入しても自分のWeb力が低いので見てくれは残念な結果となった。
• ニュースが気になる状況なので、朝一に実行しておけば、本家サイトの番組表に飛ばずに確認ができます。
• NHK番組表API 利用上の注意を確認の上、用法・用量を守ってご利用ください。