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

Django でユーザーの行動解析を行うためには、アクセス元の IP アドレスをログに残すだけでは不足しています。ユーザーを一意に識別するには、誰がアクセスしたかを HTTP サーバーのログに残すのが簡単です。

HTTP サーバーのログに Django のユーザー ID を残すには、レスポンスヘッダをカスタマイズします。汎用クラスビューで Django のユーザー ID をリクエストヘッダに追加する方法を書いておきます。

参考
https://blog.howtelevision.co.jp/entry/2014/09/05/170917

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

レスポンスヘッダを追加したビュークラスを定義

追加したいレスポンスヘッダ userid を汎用ビュークラスに追加。

custom_views.py

class CustomListView(generic.ListView):
    def dispatch(self, *args, **kwargs):
        response = super().dispatch(*args, **kwargs)
        response['userid'] = self.request.user
        return response

実際に呼び出すビュークラスを定義

ListView を継承するのではなく、CustomListView を継承して、実際に使用するビュークラスを宣言。

views.py

from .custom_views import *
from .models import MyClass
from django.contrib.auth.mixins import LoginRequiredMixin

class MemoListView(LoginRequiredMixin, CustomListView):
    model = MyClass

ListView だけでなく他のビュークラスでも同様のことは可能。

Nginx などの HTTP サーバーの設定を変更して、新たに作成したレスポンスヘッダをログに残せば、ログにアクセス元が記録される。

おしまい

少し前にConnecting Nearest Neighborのアルゴリズムでネットワークを作りたい！と相談された時に、調べまわってもPythonで、かつNetworkX等のパッケージを使ってやってみている例が見当たらなかった記憶があるので投稿します。自分だけの力で作り上げたわけではないですが、投稿にあたっていろいろ手を加え分かりやすくしました（したつもりです）。改善点等あれば、いろいろ教えていただければと思います。

環境

• python 3.6.9
• networkx 2.4
• matplotlib 3.2.1 Google Colabを使いました

NetworkXとは

公式ページ

諸先輩方がためになることを沢山書いてくださっているので、多くは語りません。

• グラフ理論とNetworkX
• 【Python】NetworkX 2.0の基礎的な使い方まとめ

を参考にしながら勉強させていただきました。

Connecting Nearest Neighborとは

Vazquezによって提案されたネットワーク生成のモデル。原著は
Growing network with local rules: Preferential attachment, clustering hierarchy, and degree correlations

自分がネットワーク関連の研究をしていたわけではないので、詳しくないですごめんなさい。
今回書き直すにあたっては

• Connecting Nearest Neighborモデルを用いたグラフの生成
• Rubyで生成したネットワークデータをd3.jsで可視化する

を参考にさせて頂きました。

アルゴリズム

1. パラメータuを定める
2. 必要なノード数になるまで、以下を繰り返す
   1. 1-uの確率で新しくノードを作成する。ランダムに既存のノードを一つ選び、新たなノードと実リンクを結ぶ。選ばれたノードと実リンクで繋がっている全ノードと、新しいノードの間に、ポテンシャルリンクを結ぶ。
   2. uの確率で、ポテンシャルリンクをランダムに選び実リンクに変える

プログラム

CNNクラス

import networkx as nx
import random
import matplotlib.pyplot as plt


class CNN:
    def __init__(self, node_num, u, seed = 0):
        self.graph = nx.Graph()
        self.node_num = node_num
        self.u = u
        random.seed(seed)
        self.make_cnn()

    def make_cnn(self):
        self.graph.add_node(0)
        while len(list(self.graph.nodes)) < self.node_num:
            # 確率uでノードを新しく追加
            if random.random() < 1 - self.u:
                new_node = len(list(self.graph.nodes))
                self.graph.add_node(new_node)
                # すでにネットワーク中に存在するノードをランダムに選ぶ
                node_list = list(self.graph.nodes)
                node_list.remove(new_node)
                selected_node = random.choice(node_list)
                # selected_nodeの隣接ノード全てにnew_nodeとのポテンシャルエッジを結ぶ
                neighbor_nodes = self.get_neighbors(selected_node)
                for nn in neighbor_nodes:
                    self.graph.add_edge(nn, new_node, attribute="potential")
                # リアルエッジを結ぶ
                self.graph.add_edge(selected_node, new_node, attribute="real")
            # 確率1-uでランダムにポテンシャルリンクを選びリアルエッジに変換
            else:
                potential_edge_list = self.get_attribute_edgelist("potential")
                if len(potential_edge_list) > 0:
                    node_a, node_b = random.choice(potential_edge_list)
                    self.graph.edges[node_a, node_b]["attribute"] = "real"


    def get_attribute_edgelist(self, attr):
        '''
        エッジの持つ値がattr(potenntialもしくはreal)のエッジのリストを返す
        '''
        # {(node, node): 属性}となるdictを取得
        edge_dict = nx.get_edge_attributes(self.graph, "attribute")
        attr_edgelist = []
        for edge, attribute in edge_dict.items():
            if attribute == attr:
                attr_edgelist.append(edge)
        return attr_edgelist

    def get_neighbors(self, node):
        '''
        nodeとreal_edgeでつながるノードのリストを返す
        '''
        edgelist = self.get_attribute_edgelist("real")
        nodelist = []
        for node_a, node_b in edgelist:
            if node_a == node:
                nodelist.append(node_b)
            elif node_b == node:
                nodelist.append(node_a)
        return nodelist

    def plot_graph(self):
        plt.figure(figsize=(15, 10), facecolor="w")
        pos = nx.spring_layout(self.graph, k=1.0)
        real_edge_list = self.get_attribute_edgelist("real")
        nx.draw_networkx_nodes(self.graph,
                               pos,
                               node_color="r")
        nx.draw_networkx_edges(self.graph, pos, edgelist=real_edge_list)
        nx.draw_networkx_labels(self.graph, pos, font_size=10)

        plt.axis("off")
        plt.show()

実行

cnn = CNN(node_num=100, u=0.9)
cnn.make_cnn()
cnn.plot_graph()

するとこんな図が得られます。

u=0.1

u=0.5

u=0.9

概要

会社の研修中にNumpy100本ノックに取り組みさせられましたが、そもそも関数を知らないと倒せない問題が数多くあり、知識不足を痛感しました。
その、僕が初めましての関数の中でも「便利だなぁ～」と思ったものを忘備録を兼ねてご紹介するのがこの記事になります。

筆者プロフィール

プログラミング歴：約1年(Pythonのみ)
Numpyはこの本で勉強しました。

初めに

初めての関数に出会ったら、ググるよりも先にhelpを見た方が圧倒的に理解が早いです。
helpは

np.info([関数名])
ex) np.info(np.add)

jupyter notebookであれば

[関数名]?
ex) np.add?

で表示されます。
関数の説明のみならず、引数の種類や使用例まで載っており、情報量がとても多いです。
英語なので慣れていないと苦痛に感じるかも知れませんが、是非参考にしていただきたいです。

「便利だなぁ～」な関数

np.flip

配列を反転します。

a = np.arange(10)
np.flip(a)
-> array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])

ベクトルであればスライス（[::-1])で事足りますが、行列の場合などに重宝しそうです。
行列の場合、axisを指定すると任意の方向にひっくり返すことができます。

a = np.arange(9).reshape(3,3)
np.flip(a)
-> array([[8, 7, 6],
          [5, 4, 3],
          [2, 1, 0]])

np.flip(a, axis=0)
->array([[6, 7, 8],
         [3, 4, 5],
         [0, 1, 2]])

np.flip(a, axis=1)
-> array([[2, 1, 0],
          [5, 4, 3],
          [8, 7, 6]])

np.eye

単位行列を生成します。

np.eye(3)
-> array([[1., 0., 0., 0.],
          [0., 1., 0., 0.],
          [0., 0., 1., 0.],
          [0., 0., 0., 1.]])

np.diag

対角成分を抽出します。

a = np.random.randint(0,10, (3,3))
print(a)
-> [[5 2 8]
    [2 7 5]
    [5 1 0]]
p.diag(a)
-> array([5, 7, 0])

np.tile

配列を敷き詰めます。

a = np.array([[0, 1], [1, 0]])
np.tile(a, (2,2))
-> array([[0, 1, 0, 1],
          [1, 0, 1, 0],
          [0, 1, 0, 1],
          [1, 0, 1, 0]])

np.bincount

配列中の数値（非負、int型）をカウントし、その値のindexに格納します。

a = np.random.randint(0, 10, 10)
print(a)
-> array([8 6 0 8 4 6 2 5 2 1])
np.bincount(a)
-> array([1, 1, 2, 0, 1, 1, 2, 0, 2], dtype=int64)

np.repeat

要素を指定した数だけ繰り返します。

np.repeat(3, 4)
-> array([3, 3, 3, 3])

np.roll

配列を指定した数だけ右にシフトします。

a = np.arange(10)
np.roll(a, 2)
-> array([8, 9, 0, 1, 2, 3, 4, 5, 6, 7])

np.flatten

元の配列を1次元配列に直します。

a = np.arange(9).reshape(3,3)
print(a)
-> [[0 1 2]
    [3 4 5]
    [6 7 8]]
b = a.flatten()
print(b)
-> [0 1 2 3 4 5 6 7 8]

np.nonzero

0以外の値が含まれているindexを教えてくれます。

a = np.array([1,0,0,1])
b = np.array([1,1,1,1])
print(np.nonzero(a))
-> (array([0, 3], dtype=int64),)
print(np.nonzero(b))
-> (array([0, 1, 2, 3], dtype=int64),)

np.copysign

第1引数の符号を第2引数と同じに変換します。

a = np.arange(10)
b = np.repeat([1, -1], 5)
np.copysign(a, b)
-> array([ 0.,  1.,  2.,  3.,  4., -5., -6., -7., -8., -9.])

np.intersect1d

2配列の共通する要素を取り出します。

a = np.arange(10)
b = np.arange(5, 15)
np.intersect1d(a, b)
-> array([5, 6, 7, 8, 9])

最後に

こういった関数は暗記するのではありませんが、そもそも知らないと使うことができません。
ご紹介した関数達が皆様の頭の片隅にでも残っていただけるととても嬉しいです！

概要

Houdini18.0からHDAのUIにPySideを使えるようになりました。
例えばこういったリストビューを使ったマテリアルを一覧し、アサインするツールを作ったりする事が可能です。

方法

HDAのUIをPySideにするにはPython Panel Editorを使います。
Python Panel Editorについては下記ページが参考になると思います。

• Houdini Python PanelでカスタムUIを作る
• Python Panel Editor(公式)
• Pythonパネルのサンプル(公式)

上記に書かれてるのはPySideのUIをHoudiniのパネルに組み込む物ですが、HDAに適用するにはShow in Parameters Paneにチェックを入れ、For Operatorsの欄にオペレータ名を指定します。

オペレータ名は<ネットワークタイプ名>/<オペレータ名>もしくは画像のようにHDAにプレフィックスを付けてる場合は<プレフィックス>::<ネットワークタイプ名>/<オペレータ名>にします。

あとはタブメニューからノードを作成するとPySideのUIが適用された状態で表示されます。

注意点

注意点としてはこのPython Panelファイル自体も読み込める場所に配置されてる必要があります。
基本的には下記どちらかに入れ、HDAは親階層のotlsフォルダに入れると自動で読み込まれます。

• $HOUDINI_PATH/python_panels
• $HOUDINI_USER_PREF_DIR/python_panels

ちなみにPython Panel Editorに使用してるコードはMayaなどのPySideが対応してるツールでも使う事が出来ます。
このツールの場合はマテリアルを適用する箇所は書き換える必要がありますが、それ以外の箇所は共通で使える為、使い回すことが出来ます。

通常のUIと切り替え

UIの表示をPySideにするか通常の物にするかは図のボタンを押すことで切り替えることが出来ます。

ちなみにMaterial Browserの通常UIはこのようになっています。

グループとマテリアルまでのパスが書かれただけのシンプルな物です。
HDAではUIをPySideにしても、パラメータの情報は通常UIからしか取得する事が出来ないので、PySideから実行するコマンドではHDA内にマテリアルを作り、選択してた面とマテリアルのパスをパラメータに設定するという処理を行っています。

問題点

本来HDAノード自体をPythonで取得しようと思うとhou.pwd()やkwargs['node']を使いますが、PySide側では取得する事が出来ません。
これが出来ないとマテリアルを適用する時にどのノードを対象にするか指定する事が出来ないのです。

この問題に対して調べても解決策が出なかったので、これはあくまで私が考えた方法ですが、HDAのOnCreatedとOnLoadedに下記スクリプトを登録しています。

def set_current_node(node, event_type, **kwargs):
    hou.setPwd(node)
node = kwargs['node']
node.addEventCallback((hou.nodeEventType.AppearanceChanged, ), set_current_node)

OnCreatedはHDA作成時、OnLoadedはシーンファイルを開いた時に実行されるスクリプトです。

• https://www.sidefx.com/ja/docs/houdini/hom/locations.html#%E3%82%A4%E3%83%98-%E3%83%B3%E3%83%88%E3%82%BF%E3%82%A4%E3%83%95

ここにaddEventCallbackでノードの状態(選択やフラグなど)が変わった時にこのHDAを現行ノードに設定するというものです。
かなり強引ですが、こうする事でPySideからhou.pwd()でHDAノードを取得する事が出来ます。

もっと良い方法をご存じの方は教えていただけると助かります…

まとめ

以上HDAのUIにPySideを使用する方法でした。

まだ対応して間もないので、情報や実装例がほとんどありませんが、HDAで出来ることの幅が増えるので、是非チャレンジしてみて下さい。

ちなみに私は今後、Houdiniからゲーム用にモデルをパブリッシュするHDAのUIをPySideに変更しようと思っています。

はじめに

本記事では「レッドコーダーが教える、競プロ・AtCoder上達のガイドライン【初級編：競プロを始めよう】」で紹介されているAOJの「Introduction To Programming I」の40問をPythonで解説します。

　僕自身、プログラム未経験で競技プログラミングをはじめました。入門書である「独学プログラマー Python言語の基本から仕事のやり方まで」を読んでから「Introduction To Programming I」に取り組みました。あくまで個人の話ですが、40問を解いたあとにはAtcoderで開催されいているAtCoder Beginner Contest（ABC）で茶パフォが出せるようになっていたので競技プログラミングをするうえでの基本的な知識は身につくのだと思います。

ITP1_1_A Hello World

ITP1_1_A

print("Hello World")

【解説】 printでHello Worldを出力します。

ITP1_1_B X:Cubic

ITP1_1_B

x=int(input())
print(x**3)

【解説】 input()は文字列として受け取るのでint()で数値にしてから処理します。

ITP1_1_C Rectangle

ITP1_1_C

a,b=map(int,input().split())
print(a*b,2*(a+b))

【解説】 1行/複数列の入力はinput().split()が利用できます。ただし文字列として受け取るのでmapとintで数値にしてから処理します。入力については「AtCoderで始めるPython入門」が参考になります。

ITP1_1_D Watch

ITP1_1_D

S=int(input())
print(S//3600,":",(S%3600)//60,":",S%60, sep="")

【解説】秒数を3600で割った商がhに、秒数を3600で割った余りを60で割った商がmに、秒数を60で割った余りがsになります。h,m,sと:を+で繋ぐにはh,m,sを文字列にする必要があります。文字列と数値が混じっていてもprintであれば問題なく出力できます。出力については「AtCoderで始めるPython入門」が参考になります。

ITP1_2_A Small, Large, or Equal

ITP1_2_A

a,b=map(int,input().split())
if a>b:
    print("a > b")
elif a<b:
    print("a < b")
else:
    print("a == b")

【解説】言われている通りに書きます。

ITP1_2_B Range

ITP1_2_B

a,b,c=map(int,input().split())
if a<b and b<c:
    print("Yes")
else:
    print("No")

【解説】a<b<cと記述しても問題ありません。

ITP1_2_C Sorting Three Numbers

ITP1_2_C

three_numbers=list(map(int,input().split()))
three_numbers.sort()
print(*three_numbers)

【解説】はじめてlistが登場します。listは複数の要素を含むオブジェクトです。「【Python入門】listの使い方とメソッドまとめ」が参考になります。もし余裕があればtuple、dictについても勉強しておくといいです。リストをソートするには、"list名".sort()もしくはsorted("list名")があります。これらの違いについては、「Pythonでリストをソートするsortとsortedの違い」が参考になります。

ITP1_2_D Circle in a Rectangle

ITP1_2_D

W,H,x,y,r = map(int,input().split())
Flag=True
if x+r>W or x-r<0:
    Flag=False
if y+r>H or y-r<0:
    Flag=False
if Flag:
    print("Yes")
else:
    print("No")

【解説】横と縦でそれぞれ円が長方形からはみ出さないかを確認します。Flagを作成しておき、条件を満たさなくなった時点でFalseにします。最後までTrueであれば、円が長方形に収まり、そうでなければ縦か横のどちらかがはみ出すことになります。TrueFalseはbool型と呼ばれます。「【Python入門】ブール型（Boolean）の用途と使い方を学ぼう！」が参考になります。

ITP1_3_A Print Many Hello World

ITP1_3_A

for i in range(1000):
    print("Hello World")

【解説】はじめて繰り返しのforの登場です。こちら「【Python入門】for文を使った繰り返し文の書き方」が参考になります。

ITP1_3_B Print Test Cases

ITP1_3_B

case_number=0
while True:
    x=int(input())
    case_number+=1
    if x==0:
        break
    print("Case {}: {}".format(case_number,x))

【解説】whileで入力が0になるまで実行します。whileについては「Pythonのwhile文によるループ処理（無限ループなど）」が参考になります。競技プログラミングではしばしばCase i:結果で出力することがあります。pythonではいくつかの出力方法がありますが、そのうちの1つとしてformatがあります。formatは文字列のメソッドで文字列内に変数を埋め込むことができます（Python2.6以降でのみ使用可能）。こちら「【Python入門】formatメソッドで変数の内容を出力する方法」が参考になります。

ITP1_3_C Swapping Two Numbers

ITP1_3_C

while True:
    x,y=map(int,input().split())
    if x==0 and y==0:
        break
    if x>y:
        print(y,x)
    else:
        print(x,y)

【解説】whileで入力が0 0になるまで実行します。あとはx,yの大小関係を確認して出力します。

ITP1_3_D How Many Divisors?

ITP1_3_D

a,b,c=map(int,input().split())
cnt=0
for k in range(a,b+1):
    if c%k==0:
        cnt+=1
print(cnt)

【解説】aからbまでの整数がcの約数かどうか1つずつ調べます。約数であればcnt（カウント）を1つ大きくします。

ITP1_4_A A/B Problem

ITP1_4_A

a,b=map(int,input().split())
print(a//b,a%b,"{:.6f}".format(a/b))

ITP1_4_A（別解）

a,b=map(int,input().split())
print(a//b,a%b,round((a/b),6))

【解説】a/bの小数の誤差をどう処理するかが問題です。formatを用いることで、数値の小数点の桁を指定できます。「Pythonのformat()メソッドを使いこなす」が参考になります。もしくは四捨五入を行い、小数の誤差を問題の制約内に抑えることも可能です。roundは厳密には四捨五入ではないので注意が必要です。四捨五入は「Pythonで小数・整数を四捨五入するroundとDecimal.quantize」が参考になります。

ITP1_4_C Simple Calculator

ITP1_4_C

while True:
    a,op,b=input().split()
    a=int(a)
    b=int(b)

    if op=="?":
         break
    if op=="+":
        print(a+b)
    if op=="-":
        print(a-b)
    if op=="*":
        print(a*b)
    if op=="/":
        print(a//b)

【解説】whileで?がでるまで実行します。あとは足し算、引き算、掛け算、割り算をそれぞれ出力します。

ITP1_4_D Min, Max and Sum

ITP1_4_D

N=int(input())
a=list(map(int,input().split()))
print(min(a),max(a),sum(a))

【解説】Pythonではlistの最大や最小、合計をそれぞれmax(list名)min(list名)sum(list名)で求めることができます。

ITP1_5_A Print a Rectangle

ITP1_5_A

while True:
    H,W= map(int,input().split())
    if H==0 and W==0:
        break
    for i in range(H):
        print("#"*W)
    print()

【解説】文字列では*は繰り返しになります。例えば"Hello World"*3とすれば"Hello WorldHello WorldHello World"となります。最後のprint()は長方形と長方形の間の1行を意味します。

ITP1_5_B Print a Frame

ITP1_5_B

while True:
    H,W= map(int,input().split())
    if H==0 and W==0:
        break
    print("#"*W)
    for i in range(H-2):
        print("#"+"."*(W-2)+"#")
    print("#"*W)
    print()

【解説】先ほどの問題に似ています。ただし、1行目とH行目は"###・・・###"ですが、2行目からH-1行目は"#…・・・…#"となります。そのため「1行目を出力」「2行目からH-1行目（つまりH-2行）までを出力」「H行目を出力」とします。

ITP1_5_C Print a Chessboard

ITP1_5_C

while True:
    H,W=map(int,input().split())
    if H==0 and W==0:
         break
    for h in range(H):
        for w in range(W):
            if (h+w)%2==0:
                print("#",end="")
            else:
                print(".",end="")
        print()
    print()

【解説】forのなかにforを書くことができます。二重ループと言われます。（参考:「Pythonで多重ループ（ネストしたforループ）からbreak」)出力したいチェック柄をじっと見ると、行数と列数を足した値が偶数の時は#、奇数の時は.であることに気づきます（Pythonでは0行目、1行目…と数えることに注意）。各行で順に出力していき、最後の列で改行します。ただprint("#")のようにすると#のあとに改行されてしまいます。それを避けるためにend=""で出力時に改行しないようにします。

ITP1_5_D Structured Programming

ITP1_5_D

N=int(input())
for i in range(1,N+1):
    if i%3==0 or "3" in str(i):
        print(" {}".format(i),end="")
print()

【解説】問題の意味をまずは理解します。C++のコードを読めないと辛い問題ですが、競技プログラミングの解説ではC++がよく使われるため、読めるようにしておくといいかもしれません。例えば通称「蟻本」と呼ばれる本もコードはC++で書かれています。今回の問題では「n以下の自然数のうち、3の倍数もしくは3がつく数を小さいものから順に出力しなさい」という問題です。3の倍数であることは3で割った余りを見ればすぐにわかります。3がつくことの確認は今回は文字列としてinを用いて行いました。任意の文字列を含むかの判定は「Pythonで文字列を検索（〜を含むか判定、位置取得、カウント）」が参考になります。

ITP1_6_A Reversing Numbers

ITP1_6_A

N=int(input())
a=list(map(int,input().split()))
a=a[::-1]
print(*a)

【解説】リストの順を逆順にするには、リスト型のメソッドreverse、組み込み関数のreversed、スライスによって並び替えることができます。今回はスライスを利用しました。リストの逆順は「Pythonでリストや文字列を逆順に並べ替え」が、スライスは「Pythonのスライスによるリストや文字列の部分選択・代入」が参考になります。

ITP1_6_B Finding Missing Cards

ITP1_6_B

N=int(input())
suits=["S","H","C","D"]
cards=[]
for _ in range(N):
    s,n=input().split()
    if s=="S":
        cards.append(int(n))   
    elif s=="H":
        cards.append(13+int(n))   
    elif s=="C":
        cards.append(26+int(n))
    else:
        cards.append(39+int(n))

for i in range(1,53):
    if i not in cards:
        print(suits[(i-1)//13],(i-1)%13+1)

【解説】トランプのマークと数字を一緒に表現する方法を考えます。スペードを1から13で、ハートを14から26で、クローバーを27から39で、ダイヤを40から52で表すことでマークと数字を同時に表せます。例えばハートの3は16となります。次に最初に持っていたカードのリストを作成します。あとは1から52までの番号（つまり52枚のトランプ全て）を一つ一つ持っているか確認して、持っていなければ出力します。

【メモ】実は計算量を意識する必要がある問題ではinを用いるのは注意が必要です。計算量については「計算量オーダーの求め方を総整理！ 〜 どこから log が出て来るか 〜」が参考になります。iがlistにあるか調べるi in listでの計算量は $O(n)$になります。これはlistにおける要素ひとつひとつとiが等しいかを確認していることになります。トランプ程度の枚数であれば問題ありませんが、大きな数になると膨大な計算量になることがあり注意が必要です。

ITP1_6_C Official House

ITP1_6_C

N=int(input())
room=[[[0]*10 for _ in range(3)] for _ in range(4)]

for _ in range(N):
    b,f,r,v=map(int,input().split())
    room[b-1][f-1][r-1]+=v

for i in range(4):
    for j in range(3):
        for k in range(10):
            print(" {}".format(room[i][j][k]), end="")
        print()
    if i!=3:
        print("####################")

【解説】この問題は多次元配列で解くことができます。「Pythonで多次元配列を扱う方法【初心者向け】」が参考になります。出力の形式を合わせるのが少し大変な問題です。

ITP1_6_D Matrix Vector Multiplication

ITP1_6_D

n,m=map(int,input().split())
A=[list(map(int,input().split())) for i in range(n)]
b=[int(input()) for i in range(m)]
for i in range(n):
    ans=0
    for j in range(m):
        ans+=A[i][j]*b[j]
    print(ans)

【解説】この問題も多次元配列で処理することで解くことができます。行列の計算になります。

ITP1_7_A Grading

ITP1_7_A

while True:
    m,f,r=map(int,input().split())
    if m==-1 and f==-1 and r==-1:
        break
    sum=m+f
    if m==-1 or f==-1 :
        print("F")
    elif sum>=80:
        print("A")
    elif sum>=65:
        print("B")
    elif sum>=50:
        print("C")
    elif sum>=30:
        if r>=50:
            print("C")
        else:
            print("D")
    else:
        print("F")

【解説】問題をよく読み、条件分岐を行います。

ITP1_7_B How many ways?

ITP1_7_C

while True:
    n,x=map(int,input().split())
    if n==0 and x==0 :
        break
    cnt=0
    for i in range(1,n-1):
        for j in range(i+1,n):
            if j<x-i-j<=n:
                cnt+=1
    print(cnt)

【解説】少し数学的な考え方が含まれる問題です。nまでの数のなかから重複無しで3つの数を足してxにすることを考えます。例えば1から5までの数から9をつくるとします。このとき、1+3+5と3+5+1は同じ数字の組み合わせなので同一の組み合わせとみなします。このような組み合わせを複数回数えることがないように、「次に選ぶ数は必ず前に選んだ数よりも大きい」というルールのもとで選んでいくことにします。はじめにiを選び、それより大きいjを選びます。あとはx-i-jがjよりも大きくn以下であれば組み合わせとして成立します。

ITP1_7_C Spreadsheet

ITP1_7_C

r,c=map(int,input().split())
sheet=[list(map(int,input().split())) for i in range(r)]
for i in range(r):
    sheet[i].append(sum(sheet[i]))
Column_sum=[0]*(c+1)
for j in range(c+1):
    for i in range(r):
        Column_sum[j]+=sheet[i][j]

for i in range(r):
    print(*sheet[i])
print(*Column_sum)

【解説】はじめにr*cの2次元配列を作成します。各行の合計と、各列の合計をそれぞれ求めて加えていきます。今までの考え方を合わせることで解ける問題です。今回は行の合計はsumで、列の合計は各行のj列目の数を一つずつ足すことで求めています。

ITP1_7_D Matrix Multiplication

ITP1_7_D

n,m,l=map(int,input().split())
A=[list(map(int,input().split())) for i in range(n)]
B=[list(map(int,input().split())) for i in range(m)]

C=[]
for i in range(n):
    line=[]
    for j in range(l):
        c=0
        for k in range(m):
            c+=A[i][k]*B[k][j]
        line.append(c)
    C.append(line)

for line in C:
    print(*line)

【解説】2次元配列を用います。インデックスを理解して書く必要があります。

ITP1_8_A Toggling Cases

ITP1_8_A

words=input()
print(str.swapcase(words))

【解説】英字の大文字と小文字の変換に利用できるメソッドはいくつかあります。そのうちの一つであるswapcaseを用いると今回の問題は簡単に解くことができます。upperやlowerなど他にも知っておくべきメソッドはあります。「Python 英字の大文字と小文字を変換(upper/lower/capitalize/swapcase/title)」を一読するといいと思います。

ITP1_8_B Sum of Numbers

ITP1_8_B

while True:
    str_n=input()
    if str_n=="0":
        break
    list_n=list(str_n)
    ans=0
    for n in list_n:
        ans+=int(n)
    print(ans)

ITP1_8_B別解

while True:
    str_n=input()
    if str_n=="0":
        break
    print(sum(list(map(int,str_n))))

【解説】今回はあえて数値を文字列として受け取ります。文字列をリストにします。例えば文字列"123"に対して、list("123")とすると["1","2","3"]となります。あとはforで各位の数を1つずつ取り出します。ただし取り出せるのは文字列としてなので、int()で数値に直してから足します。今まで標準入力で利用してきたmapを用いてより簡潔に書くこともできます。

ITP1_8_C Counting Characters

ITP1_8_C

import sys
texts=sys.stdin.read()
texts=texts.lower()
cnt=[0]*26

letters=list('abcdefghijklmnopqrstuvwxyz')
for x in texts:
    i=0
    for y in letters:
        if x==y:
            cnt[i]+=1
        i+=1
for i in range(26):
    print(letters[i]+" : "+str(cnt[i]))

【解説】今まではinputを用いて標準入力を受け取りました。今回は複数行かつ行数がわからない英文を読み取らなければいけません。whileとinputを組み合わせることも可能ですが、sysモジュールのsys.stdin.readを利用します。複数行の文字列を複数行のまま受け取ることができます。詳しくは「Python】標準入力でキーボードからデータを受け取り（sys.stdin.readlines、input関数）」を参考にして下さい。入力後は、すべて小文字にしたうえで英文の1文字ずつアルファベットを確認して、カウントしていきます。

ITP1_8_D Ring

ITP1_8_D

s=input()
p=input()
s*=2
if s.find(p)!=-1:
    print("Yes")
else :
    print("No")

【解説】リング状の文字列からある文字列を作成できるかを考えます。リング状の文字列では始まりと終わりがなくどれだけでも長い文字列を作ることができます。ただし今回の問題ではpはsよりも短いという条件がついています。そのためリング2周分で考えれば十分です。リング2周に該当する文字列を作成し、そこでpを作ることができるか調べます。pがあるかを確かめるために文字列のメソッドfindを利用します。findは特定の文字列の位置を取得しますが、文字列がなければ-1を返します。「Pythonで文字列を検索（〜を含むか判定、位置取得、カウント）」が参考になります。

ITP1_9_A Finding a Word

ITP1_9_A

import sys
word=input()
text=sys.stdin.read()
print(text.lower().split().count(word))

【解説】入力はsys.stdin.readで行います。text.lower().split().count(word)について解説します。lower()で小文字にします。split()でスペースごとに区切りリストにします。普段の標準入力でinput().split()のsplitと同様です。「Pythonで文字列を分割（区切り文字、改行、正規表現、文字数）」が参考になります。リストのなかに含まれる個数を調べるにはcountメソッドを利用します。「【Python】 特定の文字や文字列の出現回数を数える（count）」が参考になります。

ITP1_9_B Shuffle

ITP1_9_B

while True:
    cards=input()
    if cards=="-":
        break
    m=int(input())
    for i in range(m):
        sh=int(input())
        former=cards[:sh]
        later=cards[sh:]
        cards=later+former
    print(cards)

【解説】リストのスライスを利用して解くことができます。

ITP1_9_C Card Game

ITP1_9_C

n=int(input())
T=0
H=0
for i in range(n):
    card_t,card_h=input().split()
    if card_t==card_h:
        T+=1
        H+=1
    else:
        if card_h>card_t:
            H+=3
        else:
            T+=3
print(T,H)

【解説】文字列に>や<を用いると、辞書順で比較した結果が返されます。これを利用して解くことができます。

ITP1_9_D Transformation

ITP1_9_D

text=input()
n=int(input())
for i in range(n):
    order=input().split()
    a,b=map(int,order[1:3])
    if order[0]=="print":
        print(text[a:b+1])
    elif order[0]=="reverse":
        re_text=text[a:b+1]
        text=text[:a]+re_text[::-1]+text[b+1:]
    else :
        text=text[:a]+order[3]+text[b+1:]

【解説】先ほどと同じく、リストのスライスを利用して解くことができます。ただしreverseのときに少し注意が必要です。スライスでstepを-1にするときstartとendは文字通りの解釈がされません。こちらの質問が参考になります。今回はreverseしたい範囲のリストを作成してから逆順にしました。

ITP1_10_A Distance

ITP1_10_A

x1,y1,x2,y2=map(float,input().split())
print(((x1-x2)**2+(y1-y2)**2)**0.5)

【解説】ルートの計算はmathモジュールをインポートして、math.sqrt()で行うか、もしくは**0.5することで求めることができます。

ITP1_10_B Triangle

ITP1_10_B

import math
a,b,C=map(float,input().split())
θ=math.radians(C)
h=b*math.sin(θ)
S=(a*h)/2
c=math.sqrt(a**2+b**2-2*a*b*math.cos(θ))
L=a+b+c
print(S,L,h,sep="\n")

【解説】三角比はmathモジュールを利用します。ラジアンと度数法の変換は「ラジアンと度数法単位の相互変換」を、三角比は「Pythonで三角関数を計算（sin, cos, tan, arcsin, arccos, arctan）」が参考になります。cの長さは余弦定理で求めています。

ITP1_10_C Standard Deviation

ITP1_10_C

while True:
    n=int(input())
    if n==0:
        break
    score=list(map(int,input().split()))
    mean=sum(score)/n
    var_sum=0
    for i in range(n):
        var_sum+=(score[i]-mean)**2
    print((var_sum/n)**0.5)

【解説】統計量はstatisticsなどのモジュールを用いて求めることもできますが、今回は問題文にあるとおりに計算して求めます。まずは平均値を算出します。平均値との差の二乗の平均を求めます。これは分散に当たります。それのルートをとれば今回求める標準偏差になります。

ITP1_10_D Distance II

ITP1_10_D

def Distance(X,Y,p):
    s=0
    for x,y in zip(X,Y):
        s+=abs(x-y)**p
    print(s**(1/p))

n=int(input())
X=list(map(int,input().split()))
Y=list(map(int,input().split()))

for p in range(1,4):
    Distance(X,Y,p)
print(max(abs(x-y) for x,y in zip(X,Y)))

【解説】今までは既存のライブラリを利用してきましたが、自分で関数を定義することもできます。今回はDistanceという距離を出力する関数を定義します。関数の定義は「Pythonで関数を定義・呼び出し（def, return）」が参考になります。チェビシェフの距離だけは別に計算をします。またzip関数は複数のリストなどから要素を取得する時に役立ちます。「Python, zip関数の使い方: 複数のリストの要素をまとめて取得」が参考になります。

最後に

　解説を書くにあたり、できるだけ簡潔にかつできるだけ触れられる情報が多くなるように意識しました。複数のリストを用いれば解けるような問題でも敢えて多次元配列で解くようにしました。とはいえ、いきなり難しくならないように1問あたり新しいことは1つもしくは2つに収まるようにしました。ぼくもまだまだ初心者ですが、Pythonをはじめたばかりの自分が喜ぶような記事になっているとは思います。
　「Introduction To Programming I」のあとは、「レッドコーダーが教える、競プロ・AtCoder上達のガイドライン【初級編：競プロを始めよう】」で紹介されている通りに全探索の問題に取り組めばいいと思います。ぼくは全探索の問題に取り組みつつ、ABCコンテストのA問題とB問題とC問題の3問を合計30分以内に解けるように早解きの練習も行いました。皆さんの参考になれば幸いです。最後まで読んでくださりありがとうございました。
　
　
　

概要

• 新型コロナウイルス(COVID-19)の日本の感染者情報を取得
• mecabで形態素解析
• wordcloudで特徴語を可視化

参考

新型コロナウイルス(COVID-19)の感染者情報

• https://qiita.com/ryo-ma/items/20db8cd20f1086838249
  • 感染者情報と思われるデータ: https://raw.githubusercontent.com/swsoyee/2019-ncov-japan/master/Data/resultSignateDetail.csv

config

• config.py

import re
import os

### MeCab
POS_LIST = [10, 11, 31, 32, 34]
POS_LIST.extend(list(range(36,50)))
POS_LIST.extend([59, 60, 62, 67])
STOP_WORDS = ["する", "ない", "なる", "もう", "しよ", "でき", "なっ", "くっ", "やっ", "ある", "しれ", "思う", "今日", "それ", "これ", "あれ", "どれ", "どの", "NULL", "れる", "なり", "あっ", "できる", "私"]
RE_ALPHABET = re.compile("^[0-9a-zA-Z０-９ .,*<>]+$") # alphabet, number, space, comma or dot
current_dir = os.getcwd()
OUTPUT_PNG_FILE = os.path.join(current_dir, "wordcloud.png")

• 前処理

（略）

形態素解析

import MeCab
from os import path
from wordcloud import WordCloud
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import re

def create_mecab_list(text_list):
    mecab_list = []
    mecab = MeCab.Tagger("-Ochasen -d /usr/local/lib/mecab/dic/mecab-ipadic-neologd") # MacOS
    mecab.parse("")
    # encoding = text.encode('utf-8')
    for text in text_list:
        node = mecab.parseToNode(text)
        while node:
            # [品詞,品詞細分類1,品詞細分類2,品詞細分類3,活用形,活用型,原形,読み,発音]
            # 忙しく  形容詞,自立,*,*,形容詞・イ段,連用テ接続,忙しい,イソガシク,イソガシク
            morpheme = node.feature.split(",")[6]
            if RE_ALPHABET.match(morpheme):
                node = node.next
                continue
            if morpheme in STOP_WORDS:
                node = node.next
                continue
            if len(morpheme) > 1:
                if node.posid in POS_LIST:
                    mecab_list.append(morpheme)
            node = node.next
    return mecab_list

wordcloud

import MeCab
from os import path
from wordcloud import WordCloud
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import re

def create_wordcloud(morphemes):
    # fpath = "/usr/share/fonts/truetype/takao-gothic/TakaoPGothic.ttf" # Ubuntu
    fpath = "/System/Library/Fonts/ヒラギノ丸ゴ ProN W4.ttc" # Mac OS X
    wordcloud = WordCloud(
        background_color="whitesmoke",
        collocations=False,
        stopwords=set(STOP_WORDS),
        max_font_size=80,
        relative_scaling=.5,
        width=800,
        height=500,
        font_path=fpath
        ).generate(morphemes)
    plt.figure()
    plt.imshow(wordcloud)
    plt.axis("off")
    wordcloud.to_file(OUTPUT_PNG_FILE)

結果

• 「女性」より「男性」のほうが感染者が多い
  • → 「女性」より「男性」のほうが文字サイズが大きい
• 「20代」が以外に多い
• 「マスク」大事…

その他新型コロナ関連情報

• 厚生労働省
  • 新型コロナウイルスに関するQ&A:
    • https://www.mhlw.go.jp/stf/seisakunitsuite/bunya/kenkou_iryou/dengue_fever_qa_00001.html
  • 新型コロナウイルス感染症についての相談・受診の目安
    • https://www.mhlw.go.jp/content/10900000/000596905.pdf
• 東京都
  • 新型コロナウイルス感染症対策サイト
    • https://stopcovid19.metro.tokyo.lg.jp/
• 世界の感染者可視化
  • https://github.com/sorxrob/covid-3d
    • 地球儀 https://covid3d.live
  • ウーバーのエンジニアの方が作ったダッシュボード
    • PC版: https://www.arcgis.com/apps/opsdashboard/index.html#/bda7594740fd40299423467b48e9ecf6
    • Mobile版: https://www.arcgis.com/apps/opsdashboard/index.html#/85320e2ea5424dfaaa75ae62e5c06e61

目的

linux,ネットワーク、python初心者がサイバーセキュリティプログラミングを読み進めるうえで引っかかったことを残しておく。未解決も残しておく。 （進捗に応じて追記する。）

2.6 TCPプロキシの構築

引っかかったこと

• Non-ASCII character '\xe3'

  • 参考
  • Python2系ではUTF-8で書いていることを明示する必要がある
    • コメントになっているのに意味があったなんて…

• 実行にあたって

  • sudo ./proxy.py 127.0.0.1 21 ftp.example.com 21 True
    • これ実行できない気がするんだけど…
  • sudo しなくても21番待ち受けはできてるっぽい（root権限だからかな…）
  • FTPクライアントソフトを21番ポートで"別に"起動しなければならない
  • kali linux標準？でftpサーバは起動できそう
  • server.accept()で応答が返ってこない。。。
  • 同様のことを、外部ftpサーバ利用して試している人がいるので、真似してみようかな…参考
  • ↑kaliからfilezillaで接続できないftpサーバをvsftpdでローカルに立ててみた。server.acceptでとまることはなくなったが、データのやり取りじたいはできてないみたい。。。

• Wing IDEでタブやスペースを明示的に表示したい

  • 初っ端のインデントずれを直すのに苦労

はじめに

TwitchのBotってPythonで作れるのかな～と調べていたところ日本語の記事が見つからず、英語アレルギーの自分には苦しい翻訳作業の連続だったので、僕と同じような英語アレルギーの人のお役に立てたらなと記事にして残しておきたいと思います。

TwitchIOというラッパーで簡単に作れるようなので、今回はこれを使用してBotを実際に作るところまで1から説明していきたいと思います。(エディタは省略)
原理まで書くととても長くなってしまうので機能を深く掘り下げるのはまた今度として、挨拶を返してくれるBotが完成するところまでです。面倒くさいわけでは決してありません(クソデカボイス)

この記事をきっかけに日本人ユーザーが増えてQiitaの記事も沢山出始めてくれたらな～と願っています。

また、間違った説明をしてしまっている箇所がありましたらコメントの方にお願いします

TwitchIOとは

https://github.com/TwitchIO/TwitchIO

An Asynchronous IRC/API Wrapper currently in Development for TwitchBots made in Python!
(https://pypi.org/project/twitchio/ より引用)

PythonでTwitchのBotを作ることが出来るラッパーだよ！と思ってもらえれば大体あってます。
Let's make a Twitch bot with Python!という記事を参考にしながら作成していきます。

OSはWindows 10を使用しています。
といってもMacでもやり方はほぼ変わりません。

手順

1. Twitchアカウントの作成
2. Pythonをインストール
3. TwitchIOをインストール
4. OAuthパスワードを作成
5. Twitch Developersでアプリケーション登録
6. コーディング
7. 実践テスト

1. Twitchアカウントの作成

まずはBotとして扱うTwitchのアカウントを作成していきます。
そのアカウントそのものがBotとして動作するので、普段配信や視聴しているアカウントとは別で作成したほうがいいと思います。

これは自分のアカウントでbot登録してしまった為、自らがbot化してしまったmaguro869 pic.twitter.com/EhBItUtmeH

— ? (@maguro869) April 8, 2020

今後Botを運用していく上で、Botが発言したことは無視するように設計しますので放送主のアカウントではBotを作らないようにして下さい。
そういう設計をしなかったとしてもちょっと寂しいBotになってしまいます。

https://www.twitch.tv/ を開いて右上の「登録」をクリックして下さい。
(既に普段使いのアカウントでログインしている場合はログアウトしてから)

アカウント情報を入力して「登録」をクリックしてください。
今回私はsalmon869という名前のBotを作成します。サーモンよりマグロの方が絶対おいしい

登録したメールアドレスの方にTwitchから6桁のアカウント認証コードが届いていると思うので、遷移した画面にそれを入力してください。
(Gmailだとプロモーションの所に届いていたので見つけづらいかもしれません...)

これにてアカウント登録は完了です。

この後、Twitch Developersにアプリケーション登録する際に2段階認証を済ませておく必要があるので、それを先にしておきましょう。

https://www.twitch.tv/settings/security こちらのページを開いて「セキュリティ」のところにある「2段階認証」の「2段階認証を設定する」というボタンをクリックして下さい。

左側は+81を選択し右側にお使いの携帯番号を入力して下さい。続行を押すと携帯の方に認証コードが記載されているSMSが届きます。
それを入力して認証完了です。

これでBotに使用するアカウントの準備は完了です。

2. Pythonをインストール

Githubには

TwitchIO requires Python 3.6 or higher.

と書いてありますので、最新版でも対応してるみたいです。
2020/04/09現在で最新のPython3.8.2をインストールします。
既に3.6より上のバージョンをインストールしている場合は次の「3. TwitchIOをインストール」に進んでも大丈夫です。

https://www.python.org/downloads/ を開いて「Download Python 3.8.2」をクリックして下さい。
ダウンロードされた「python-3.8.2.exe」を起動してください。

「Add Python 3.8 to PATH」にチェックを入れた後、「Install Now」をクリックして下さい。

この画面になったら完了です。「Close」をクリックして閉じて大丈夫です。
これでPythonのインストールは完了です。

3. TwitchIOをインストール

TwitchIOをインストールするにはpipコマンドを使用します。

デスクトップ左下のWindowsマークをクリックし、「cmd」と入力すると「コマンドプロンプト」と検索結果に出ますのでクリックして下さい。

起動したら「py -m pip install twitchio」と入力してEnterキーを押して下さい。
色々バーっと出た後に「Successfully installed twitchio-1.0.0」と出たらインストール完了です。

4. OAuthパスワードを作成

TwitchのAPIを利用するためにはOAuthパスワードを取得する必要があります。
https://twitchapps.com/tmi/ このサイトでとても簡単に取得可能です。

「Connect」をクリックして下さい。

「許可」をクリックして下さい。

「oauth:~」とパスワードが表示されるのでどこかにメモをしておいて下さい。
これでOAuthパスワードの作成は完了です。

5. Twitch Developersでアプリケーション登録

続いて、Twitch Developersでアプリケーション登録をしてクライアントIDを取得します。
https://dev.twitch.tv/console/apps/create を開いてください。

「Authorize」をクリックして承認してください。

このような画面に遷移するのでそれぞれの項目を入力/選択してください。

• 名前：Botのアカウント名(分かりやすければOK)
• OAuthのリダイレクトURL：先ほどメモしたoauth:~
• カテゴリー：Chat Botを選択

終わったら「作成」をクリックして下さい。

このような画面に遷移したら「管理」をクリックして下さい。

クライアントIDが記載されているのでそれをメモしておいてください。今回はシークレットトークンは使用しないので作成しなくて結構です。

これでTwitch Developersでアプリケーション登録は完了です。

6. コーディング

それでは実際にコーディングしていきましょう。

Twitch_botというフォルダを作成し、その中で作業していきます。
まずはデータを格納しておくconfig.pyを作成します。
以下は例ですので各々の情報を入力してください。

Twitch_bot/config.py

TMI_TOKEN = 'oauth:~'       # メモしたoauth:~のアレ
CLIENT_ID = 'xxxxxxxxxxxxxxxxxxxx'    # メモしたクライアントID
BOT_NICK = 'salmon869'      # Botのアカウント名
BOT_PREFIX = '!'    # この文字を作成したコマンドの頭に付けることでコマンドと認識してくれます
CHANNEL = ['maguro869'] # 実際に配信をするアカウント名

これでmaguro869というアカウントで動くBotのconfig.pyは作成できました。
続いてBotの本体となるbot.pyを作成します。

Twitch_bot/bot.py

from twitchio.ext import commands
from config import *

bot = commands.Bot(
    irc_token=TMI_TOKEN,
    client_id=CLIENT_ID,
    nick=BOT_NICK,
    prefix=BOT_PREFIX,
    initial_channels=CHANNEL
)

@bot.event
async def event_ready():
    print(f"{BOT_NICK}がオンラインになりました!")

if __name__ == "__main__":
     bot.run()

これでコーディングは終了です。

7. 実践テスト

入力が終わったら一度実行してみましょう。

Twitch_botフォルダを開いてShiftを押したまま右クリックして「PowerShellウィンドウをここで開く」でPowerShellを開いてください。機能としては大体コマンドプロンプトと同じです(大きいお友達のみんな、怒らないで)

起動したら「py bot.py」と入力しEnterキーを押してBotを起動してみましょう。
「｛Botのアカウント名｝がオンラインになりました!」と表示されたら正常に起動出来ています。

しかし、これだけではコマンドの実装は何も出来ていないのでbot.pyを以下のように編集して挨拶を返してくれるようにしましょう。

Twitch_bot/bot.py

from twitchio.ext import commands
from config import *

bot = commands.Bot(
    irc_token=TMI_TOKEN,
    client_id=CLIENT_ID,
    nick=BOT_NICK,
    prefix=BOT_PREFIX,
    initial_channels=CHANNEL
)

@bot.event
async def event_ready():
    print(f"{BOT_NICK}がオンラインになりました!")

# ここから追加

@bot.command(name='hello')
async def hello(ctx):
    await ctx.channel.send(f'{ctx.author.name}さん こんにちは～ VoHiYo')

# ここまで追加

if __name__ == "__main__":
     bot.run()

これでBotを起動した後に「!hello」と配信チャットを打つと「○○さん こんにちわ～ VoHiYo」とBotが発言してくれるようになります。
※ VoHiYoとはTwitchが絵文字として認識してくれる単語の一つです。

実行結果で確認してみましょう。

これで挨拶機能の実装、Botの運用に成功しました。
お疲れ様でした！

おわりに

現段階では挨拶の機能しかありませんが、勿論オリジナリティー溢れるコマンドを用意することもできます。
あなたのアイデア次第でBotは無限の可能性を秘めています。
是非公式ドキュメントとにらめっこしながらあなただけのBotを作ってみてください！
TwitchIOコミュニティーの繁栄を願っています

参考資料

Let's make a Twitch bot with Python!
TwitchIO(Github)
TwitchIO Document

ABC161 C - Replacing Integer

問題文

青木君は任意の整数$x$に対し、以下の操作を行うことができます。

操作

$x$を$x$と$K$の差の絶対値で置き換える。

整数 Nの初期値が与えられます。この整数に上記の操作を0回以上好きな回数行った時、とりうるNの最小値を求めてください。

制約

$$
0≤N≤10^{18}
$$
$$
1≤K≤10^{18}
$$
入力は全て整数

C - Replacing Integer

解法

行う操作は、例えば$N=7$、$K=4$のとき$x$から$K$を差分の絶対値が最小になるまで引くことなので、$x=7,x=3,x=1,x=3$と$x$が変化していく。
よって求める$x$は$1$となる。
なお、$x=1$以降は$x$は$1$と$3$を繰り返す。

ただこの操作を$N$と$K$が大きいときに愚直に繰り返すと大変なので、求める最小値は$N/K$の余りか$K - (N/K)$の余りであることを利用する。

N, K = map(int,input().split())

print(min(N % K, K - (N % K)))

間違いがある場合は指摘してください。

Pythonで簡易営業ツール作成方法:社員番号検索

営業でちょっとしたときに作成したツールを共有します。
Googleで調べながらSpyder(Python3.7)で作成してみました。

import tkinter as tk
root=tk.Tk()
root.geometry('300x200')
root.title('社員')
def btn_click():
    x=txt_1.get()
    if x=="田中":
        txt_2.insert(0,1)     
    elif x=="鈴木":
        txt_2.insert(0,2)
    elif x=="山田":
        txt_2.insert(0,3)
    else:
        txt_2.insert(0,"該当なし")
lbl_1 = tk.Label(text='苗字')
lbl_1.place(x=30, y=70)
lbl_2 = tk.Label(text='社員番号')
lbl_2.place(x=30, y=100)
txt_1 = tk.Entry(width=20)
txt_1.place(x=90, y=70)
txt_2 = tk.Entry(width=20)
txt_2.place(x=90, y=100)
btn = tk.Button(root, text='実行', command=btn_click)
btn.place(x=140, y=170)
root.mainloop()

基本はこれで最後です。

関数、組込関数

プログラムのまとまりを関数として定義して使うことができます。

また、pythonそのものに予め設定されてる関数を
組込関数といいます。

変数のプログラム番と考えればいいかと

メソッド

特定の値に大して処理を行う物をメソッドといいます。

メソッド

値.メソッド名()

という形で書きます。

また、値の要素などを取り出すインスタンス変数というものもあります。
インスタンス変数は関数ではなく変数なので引数を持ちません。

インスタンス変数

値.インスタンス変数名 

という形式で書きます。

appendを例に出すと以下のようになります。

append

# append()は、リストに新しい要素を１つだけ追加したい場合に使用するメソッドです。

alphabet = ["a","b","c","d","e"]
alphabet.append("f")
print(alphabet) 
# ["a", "b", "c", "d", "e", "f"]が出力される

文字列型のメソッド（upper/count)

文字の拡大と、数えを行うメソッドです。

city = "Tokyo"
print(city.upper()) # 「TOKYO」が出力される
print(city.count("o")) # 「2」が出力される。

文字列型のメソッド（format）

format()メソッド は文字列型に使えるメソッドで、文字列に変数を埋め込むことができます。
主にテンプレートに変数の値を挿入するときに使用します。
値を埋め込みたい箇所を{}で指定します。引数は文字列型でなくても構いません。

print("私は{}生まれ、{}育ち".format("東京", "埼玉"))
# 「私は東京生まれ、埼玉育ち」と出力される


# {}に挿入する値は、挿入する順番を指定することも可能です。また、同じ値を繰り返し挿入することもできます。

print("私は{1}生まれ、{0}育ち、{1}在住".format("東京", "埼玉"))
# 「私は埼玉生まれ、東京育ち、埼玉在住」と出力される

リスト型のメソッド（index）

リスト型にはインデックス番号が存在します。

インデックス番号とは、リストの中身を0から順番に数えた時の番号です。

目的のオブジェクトが どのインデックス番号にあるのか探すためのメソッド として

index()

があります。
また、リスト型でも先ほど扱った

count()

を使うことができます。

alphabet = ["a", "b", "c", "d", "d"]
print(alphabet.index("a")) 
# インデックス番号0番目にあるので、「0」と出力されます
print(alphabet.count("d")) 
# "d"がインデックス番号3番目と4番目にあるので、「2」と出力されます

リスト型のメソッド（sort,reverse,sorted）

sort()

これはリストの中を小さい順に並べ替えてくれます。

reverse()

これを用いるとリストの要素の順番を反対 にすることができます。

注意点として

• sort()メソッドやreverse()メソッドを使うと、リストの中身が直接変更されます。
• 戻り値をとらないので、print(list.sort())としてもNoneが返ってきます。

並べ替えたリストを参照したいだけであれば、ソート後の配列を戻り値としている組み込み関数のsorted()を使います。

soted()

使用例はこちらです。

# sort()の利用例

list = [1, 10, 2, 20]
list.sort()
print(list) # [1, 2, 10, 20]と表示されます。

# reverse()の利用例

list = ["あ", "い", "う", "え", "お"]
list.reverse()
print(list) # ["お", "え", "う", "い", "あ"]と表示されます。

関数

下記のように作成します。

「 def 関数名(): 」

関数には必要な処理をまとめられるのでプログラムが簡潔になり
全体の動きが把握しやすくなるというメリットがあります。

同じ処理を複数箇所で使い回すことができ 記述量の削減 、 可読性の向上 に繋がります。

def sing():
    print ("歌います！")

# インデントで処理の範囲を明示します。
# また、定義した関数の呼び出しは「関数名()」と書きます。

sing() 
 # 出力結果 歌います!

引数

関数を定義する際に 引数(argument)を設定しておけば、
関数内でその値を使用できるようになります。

def 関数名(引数):

def introduce(n):
    print(n + "です")

introduce("Yamada")
# 「Yamadaです」と出力される
# この時、引数を変数で指定すると、引数を直接変えなくても出力結果を変えること ができます。

def introduce(n):
    print(n + "です")

name = "Yamada"
introduce(name) # 「Yamadaです」と出力される

name = "Tanaka"
introduce(name) # 「Tanakaです」と出力される
# なお、関数内で定義した変数や引数は、関数内でのみ使用可能となります。

複数の引数

引数はカンマで区切って複数指定することが可能 です。

def introduce(first, family):
    print("名字は" + family + "で、名前は" + first + "です。")

introduce("taro", "Yamada") 
# 「名字はYamadaで、名前はtaroです。」と出力される

引数の初期値

引数に 初期(デフォルト)値を設定すると
引数が空欄の場合、自動的に初期値が設定されます。 引数 = 初期値 という形で設定します。

def introduce(family="Yamada", first="Taro"):
    print("名字は" + family + "で、名前は" + first + "です。")


introduce("Suzuki")
# 「名字はSuzukiで、名前はTaroです。」と出力される
# この場合は、firstのみが初期値として設定され、familyは"Suzuki"で上書きされています。

# もしfirstの引数のみ渡したい場合はintroduce(first="Jiro")と指定してあげればよいです。

# なお、初期値を設定した引数の後ろの引数にも、必ず初期値を設定する必要があります。
# したがって、次のように後ろの引数にだけ初期値を設定することは可能です。

def introduce(family, first="Taro"):
    print("名字は" + family + "で、名前は"+ first + "です。")
# しかし、次のように前の引数にだけ初期値を設定し、後ろの引数に設定しないとエラーになります。

def introduce(family="Suzuki", first):
    print("名字は" + family + "で、名前は" + first + "です。")
# この場合に出力されるエラーは、non-default argument follows default argumentです。

return

関数で定義した変数や引数は関数外では使用できません。
しかし、returnを使用することで、関数の呼び出し元に戻り値を渡すことができるようになります。

error

ef introduce(family = "Yamada", first = "Taro"):
    comment = "名字は" + family + "で、名前は" + first + "です。"

print(introduce("Suzuki")) 
# Noneが出力される
# こちらは戻り値がないので、出力結果がNone(なし)になります。

def introduce(family = "Yamada", first = "Taro"):
    comment = "名字は" + family + "で、名前は" + first + "です。"
    return comment #関数に戻り値を渡す

print(introduce("Suzuki")) 
# 「名字はSuzukiで、名前はTaroです。」と出力される

このように、returnを使用することで、関数の呼び出し元に戻り値を渡すことができるのです。

関数のインポート(パッケージ、サブパッケージ 、モジュール)

関数のインポートとして直近でモジュールから
そのまとまりをパッケージから取り出す形式です。

scipyパッケージとtimeモジュールなどがあります。

• パッケージ: 関連する複数のモジュールを一つのディレクトリにまとめた物

• サブパッケージ: パッケージの中にさらにパッケージが入れ子になっていることもあります。 この場合入れ子になっている方のパッケージを と呼びます。

• モジュール: 頻繁に行われるいくつかの処理を一つのファイルにまとめ、他のソースコードから利用できるようにした物

プログラム内でパッケージやモジュールを使用する際には、下記のような インポートという処理が必要になります。

import scipy # scipyパッケージをインポートする
import time # timeモジュールをインポートする

# インポートしたパッケージ内のメソッドを使用する場合
# 一般的には、 パッケージ名.サブパッケージ名.メソッド名 と書きます。メソッドと同様の仕組みだと覚えていてください。

import scipy.linalg

scipy.linalg.norm([1,1])

> 出力結果
1.4142135623730951

下記の例ではtimeモジュールのtimeというメソッドを使用して、現在の時刻を出力しています。

import time

now_time = time.time() #現在時刻をnow_timeに代入する

print(now_time) #現在時刻が出力される

また、from パッケージ名.サブパッケージ名 import メソッド名 という書き方で
メソッドを直接読み込む方法もあります。この場合はメソッド呼び出しの際に
パッケージ名・サブパッケージ名が省略できます。

from scipy.linalg import norm

norm([1, 1]) # パッケージ名・モジュール名を省略できる

# 出力結果
1.4142135623730951

from モジュール名 import メソッド名 という書き方でモジュール名を省略することができます。

from time import time # timeモジュールのtimeメソッドをインポートする

now_time = time() #モジュール名を省略できる

print(now_time) #現在時刻が出力される

import パッケージ名 as 呼称とすることで
任意の名前でパッケージを呼び出すことができます。

from time import time as t 
# timeモジュールのtimeメソッドをインポートしてtという名前で扱う

now_time = t()

print(now_time) #現在時刻が出力される

クラス

オブジェクト

Pythonは オブジェクト指向言語です。
オブジェクトとは、データやそのデータに対する手続き(メソッド)を一つにまとめたものを言います。

手続きとは、オブジェクトが持つ処理を記述したものです。
オブジェクトのイメージとしては設計図です。オブジェクトをインスタンス化(実体化)して
メッセージ(命令)を送ると処理が行われます。

処理対象をオブジェクトとして捉え、それをモジュール化することでプログラムを再利用するやり方のことを
オブジェクト指向と言います。

クラス

オブジェクトの構造の設計図のようなものです。
大判焼きで言うなら。

クラス: 型
インスタンス: 大判焼き
オブジェクト: 大判焼きセット(クラス+インスタンス)

クラスの内容

クラスにはイニシャライザ、メソッド、メンバ変数などが含まれています。

• イニシャライザ: クラスからインスタンスが生成された直後に実行される処理のことです。基本的に一度だけ呼び出されます。 下記の名前で作ると構文で決まっています。

__init__()

• メソッド: 以前説明した通り

• メンバ変数はクラス内で使用する変数のことです。

class MyProduct: #クラスを定義
    def __init__(self, name, price): # イニシャライザを定義
        self.name = name # 引数をメンバに格納
        self.price = price
        self.stock = 0
        self.sales = 0
# 定義したクラスからインスタンスを生成

# MyProductを呼び出し、product1を作成
product1 = MyProduct("cake", 500)

print(product1.name) # product1のnameを出力
cake

print(product1.price) # product1のpriceを出力
500

クラスのルール(self,イニシャライザ)

• クラス名の先頭文字を大文字にする
  慣習であり複数の単語を含む場合は
  それぞれの先頭をMyProductというように大文字にします。

• 初期化( init ,selfz)
  クラスは設計図ですので、インスタンスを生成する際に初期化が必要です
  イニシャライザは init という名前で定義し
  第一引数を selfにするという慣例があります。

 class MyProduct: #クラスを定義
    def __init__(self, 引数): # イニシャライザを定義

• selfの使用

selfはインスタンス本体(この場合MyProduct)を参照しており
selfを使用することでインスタンスが持つ他のメンバ変数を取得したり
メソッドを呼び出すことができます。

例

class MyProduct: #クラスを定義
    def __init__(self, name, price): # イニシャライザを定義
        self.name = name # 引数をメンバに格納
        self.price = price
        self.stock = 0 # stock, salesは0で初期化
        self.sales = 0
# 次に、定義したクラスからインスタンスを生成。 
# インスタンス生成では、クラス(MyProduct)を呼び出して変数に代入します。

# MyProductを呼び出し、product1を作成
product1 = MyProduct("cake", 500)

print(product1.name) # product1のnameを出力
> 出力結果
cake

print(product1.price) # product1のpriceを出力
> 出力結果
500

print(product1.stock)
> 出力結果
0

クラス（メソッド）

クラスで定義できるメソッドには以下の3種類あります。

• 通常のメソッド ... 第一引数がselfになります。
• クラスメソッド ... クラス全体の操作を行う。
• スタティックメソッド(静的メソッド) ... 引数がなくても実行できる。

class MyClass:  # クラス名
    def __init__(self, 引数2, 引数3, …):  # イニシャライザ
        self.変数名 = 初期値  # 変数を初期化する

    def normal_method(self, 引数2, 引数3, …):  # 通常メソッド
        self.name = name
        return name

    @classmethod  # クラスメソッド 
    #クラスメソッドは第一引数をclsにするという決まりがあります。
    def class_method(cls, 引数2, 引数3, …):
        cls.name = cname
        return cname

    @staticmethod  # スタティックメソッド　
    #スタティックメソッドは決まりがなく、引数自体が必須ではありません。
    def static_method(引数1, 引数2, 引数3, …):
        引数1.name = sname
        return sname

クラスメソッドは第一引数をclsにするという決まりがありますが
スタティックメソッドは決まりがなく、引数自体が必須ではありません。

また、メソッドの呼び出しは、オブジェクト.メソッド名と書きます。

オビジェクト.メソッド名

クラス（継承、オーバーライド、スーパー）

• 継承(インヘリタンス): クラスの内容を継承させる。

• オーバーライド: 継承したクラスで継承元のクラスのメソッドを上書きすること

• 親クラス、スーパークラス、基底クラス: 継承元のクラス

• 子クラス、サブクラス、派生クラス: 継承先のクラス

# 親クラス
class MyProduct:
    def __init__(self, name, price, stock):
        self.name = name
        self.price = price
        self.stock = stock
        self.sales = 0

    def buy_up(self, n): # 仕入れメソッド
        self.stock += n

    def get_name(self): # 商品名メソッド
        return self.name

    def sell(self, n): # 販売メソッド
        self.stock -= n
        self.sales += n * self.price

    def summary(self): # 概要メソッド
        message = "called summary().\n name: " + self.name + \
        "\n price: " + str(self.price) + \
        "\n price: " + str(self.get_price_with_tax()) + \
        "\n sales: " + str(self.sales)
        print(message)

# 継承の手順は下記の通りです。


# MyProductクラスを継承してMyProductSalesTaxを定義
class MyProductSalesTax(MyProduct):

    # イニシャライザの第四引数に消費税率を設定
    def __init__(self, name, price, stock, tax_rate):
        #親クラスのイニシャライザを呼び出す
        super().__init__(name, price, stock)
        self.tax_rate = tax_rate

    # MyProductのget_nameを上書き
    def get_name(self):
        return self.name + "(税込)"

    #get_price_with_taxを追加
    def get_price_with_tax(self):
        return int(self.price * (1 + self.tax_rate))
# super()で親クラスのメソッドを呼び出すことができます。このプログラムを実行すると下記のようになります。

product_3 = MyProductSalesTax("phone", 30000, 100, 0.1)
print(product_3.get_name())
print(product_3.get_price_with_tax())
# MyProductのsummaryメソッドを呼び出す
product_3.summary()

phone(税込) # 期待通りの出力
33000      # 期待通りの出力
called summary() 
name: phone
price: 30000
stock: 100
sales: 0

文字列のフォーマット指定

コンソールに出力する文字列の書式は「formatメソッド」を使って形式を整えられます。
文字列に含まれる数値部分を整える場合に、使用する書式を一部紹介します。　　

:d int型のデータを10進法で表示
:.0f float型データの整数部分のみ表示
:.2f float型データの小数第2位まで表示
これらの書式は以下に例示するコードのように使います。

# 円周率の近似値を定義
pi = 3.141592
 #円周率を3として定義
pi2 = 3
print("円周率は{:d}".format(pi2)) # 「円周率は3」と出力される
print("円周率は{:.0f}".format(pi)) # 「円周率は3」と出力される
print("円周率は{:.2f}".format(pi)) # 「円周率は3.14」と出力される。

はじめに

私の最初の記事で，TSPをQAOAで解いてみたというものを投稿しました．しかし，これはqiskit aquaという自分で回路を設計しなくても可能ないわゆるモジュール化されたものを使用していました．
そこで今回はqiskit aquaを使わずにQAOAを使ってみたいと思います．まず，最初の段階としてmax cutを用います．正直，他の問題もハミルトニアンを変更するだけでなんとかなると思いますので，qiskitで量子プログラミングをしていく人たちの参考になればなと思います．
日本語で量子プログラミングを解説いているサイトは複数ありますが，どれも別の量子プログラミング言語を用いていることから，qiskitで記述している私の記事にも意味はあると考えています．

なお，今回の記事でもQAOA自体の解説は他の方にお任せするとしてqiskitのコードの解説をしていきたいと思います．

参考: Quantum Native Dojo

code

まずは全体のcodeを

# coding: utf-8

from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
from qiskit.aqua.utils import tensorproduct
from qiskit import BasicAer
from qiskit.quantum_info.analysis import average_data

from scipy.optimize import minimize
import numpy as np
import time


def classical_minimize(cost_func, initial_params, options, method='powell'):
    print('classical minimize is starting now... ')
    start_time = time.time()
    result = minimize(cost_func, initial_params, options=options, method=method)
    print('running time: {}'.format(time.time() - start_time))
    print('opt_cost: {}'.format(result.fun))
    print('opt_params: {}'.format(result.x))
    return result.x


class MAXCUT:

    # 初期値設定
    def __init__(self, n_qubits, weight_matrix, p=1, num_steps=1):
        self.n_qubits = n_qubits
        self.weight_matrix = weight_matrix
        self.P = p
        self.num_steps = num_steps
        self.edge_list = []
        self._make_edge_list()

    # edge list の作成 from weight matrix
    def _make_edge_list(self):
        for i in range(self.weight_matrix.shape[0]):
            for j in range(i+1, self.weight_matrix.shape[1]):
                if self.weight_matrix[i][j] != 0:
                    self.edge_list.append([i, j])

    '------------------------------------------------------------------------------------------------------------------'

    def Zi_Zj(self, q1, q2):
        I_mat = np.array([[1, 0], [0, 1]])
        Z_mat = np.array([[1, 0], [0, -1]])
        if q1 == 0 or q2 == 0:
            tensor = Z_mat
        else:
            tensor = I_mat
        for i in range(1, self.n_qubits):
            if i == q1 or i == q2:
                tensor = tensorproduct(tensor, Z_mat)
            else:
                tensor = tensorproduct(tensor, I_mat)
        return tensor

    def observable(self):
        obs = np.zeros((2**self.n_qubits, 2**self.n_qubits))
        for a_edge in self.edge_list:
            q1, q2 = a_edge
            obs = obs + 0.5 * self.Zi_Zj(q1, q2)
        return obs

    '------------------------------------------------------------------------------------------------------------------'

    # U_C(gamma)
    def add_U_C(self, qc, gamma):
        for a_edge in self.edge_list:
            q1, q2 = a_edge
            qc.cx(q1, q2)
            qc.rz(-2**gamma, q2)
            qc.cx(q1, q2)
        return qc

    # U_X(beta)
    def add_U_X(self, qc, beta):
        for i in range(self.n_qubits):
            qc.rx(-2*beta, i)
        return qc

    def QAOA_output_onelayer(self, params, run=False):
        beta, gamma = params
        qr = QuantumRegister(self.n_qubits)
        cr = ClassicalRegister(self.n_qubits)
        qc = QuantumCircuit(qr, cr)
        qc.h(range(self.n_qubits))
        qc = self.add_U_C(qc, gamma)
        qc = self.add_U_X(qc, beta)
        qc.measure(range(self.n_qubits), range(self.n_qubits))
        NUM_SHOTS = 10000
        seed = 1234
        backend = BasicAer.get_backend('qasm_simulator')
        results = execute(qc, backend, shots=NUM_SHOTS, seed_simulator=seed).result()
        counts = results.get_counts(qc)
        expectation = average_data(counts, self.observable())
        return expectation

    '------------------------------------------------------------------------------------------------------------------'

    def minimize(self):
        initial_params = np.array([0.1, 0.1])
        opt_params = classical_minimize(self.QAOA_output_onelayer, initial_params,
                                        options={'maxiter':500}, method='powell')
        return opt_params

    def run(self):
        opt_params = self.minimize()
        beta_opt, gamma_opt = opt_params
        qr = QuantumRegister(self.n_qubits)
        cr = ClassicalRegister(self.n_qubits)
        qc = QuantumCircuit(qr, cr)
        qc.h(range(self.n_qubits))
        qc = self.add_U_C(qc, gamma_opt)
        qc = self.add_U_X(qc, beta_opt)
        qc.measure(range(self.n_qubits), range(self.n_qubits))
        NUM_SHOTS = 10000
        seed = 1234
        backend = BasicAer.get_backend('qasm_simulator')
        results = execute(qc, backend, shots=NUM_SHOTS, seed_simulator=seed).result()
        print(results.get_counts())


if __name__ == '__main__':
    weight_matrix = np.array([[0, 1, 0, 1],
                             [1, 0, 1, 0],
                             [0, 1, 0, 1],
                             [1, 0, 1, 0]])
    cut = MAXCUT(4, weight_matrix, p=1)
    cut.run()

気になる関数だけをピックアップして解説していきます．

C(Z)の作成

    def Zi_Zj(self, q1, q2):
        I_mat = np.array([[1, 0], [0, 1]])
        Z_mat = np.array([[1, 0], [0, -1]])
        if q1 == 0 or q2 == 0:
            tensor = Z_mat
        else:
            tensor = I_mat
        for i in range(1, self.n_qubits):
            if i == q1 or i == q2:
                tensor = tensorproduct(tensor, Z_mat)
            else:
                tensor = tensorproduct(tensor, I_mat)
        return tensor

    def observable(self):
        obs = np.zeros((2**self.n_qubits, 2**self.n_qubits))
        for a_edge in self.edge_list:
            q1, q2 = a_edge
            obs = obs + 0.5 * self.Zi_Zj(q1, q2)
        return obs

<\beta,\gamma|C(Z)|\beta,\gamma>

を計算する際に必要なC(Z)をここで作成しています．
この際にテンソル積を計算する必要がありますが，qiskit.aqua.utilsのtensorproductで計算可能です．

期待値の計算

qiskitで期待値を計算するには

        results = execute(qc, backend, shots=NUM_SHOTS, seed_simulator=seed).result()
        counts = results.get_counts(qc)
        expectation = average_data(counts, self.observable())

の方法でできます．

結果

実行結果は以下の通りになりました．

{'0101': 2578, '1110': 171, '1101': 146, '1001': 793, '1111': 141, '0011': 815, '0111': 122, '0010': 159, '0000': 161, '0100': 170, '0001': 151, '0110': 802, '1000': 160, '1100': 811, '1010': 2682, '1011': 138}

値が大きい，0101と1010が解として取り出すことができます．