概要

競馬 × AIの話題を見かけることがここ数年で増えましたが、全レースを対象としたものも多く、
個人的に気になる事例に絞って分析してみたい！と思い、今回netkeiba-scraperを使用していじってみました。

今回絞るテーマは「単勝1倍台の馬が出走するレースの買い方」です。
2019年は日本ダービーや阪神JF、有馬記念など、単勝1倍台の馬が馬券外に沈むケースも多く見られました。
あくまで単勝馬券で分析は進めました。

※SQLをPythonでいじる練習も兼ねていますので、コードの書き方ご指導いただけると嬉しいです！

netkeiba-scraperでデータ取得

競馬データのスクレイピングについては、偉大なる先人のコードを使用させていただきました。
gitHubはこちら

過去10年分のデータを取得しました。
特徴量抽出のためのgenfeatureは、処理に40日くらいかかりそうだったため使用しませんでした。
またJRAのクラス呼称が変更された(ex. 500万下→1勝クラス)ため、Scalaコードを直さないと適切にgenfeatureできなさそうです。

DLしたrace.dbファイルをPythonで読み込み、データ分析を開始します。

Jupyter NotebookでSQLiteを読み込む

dbconnect

import sqlite3 as sq

conn = sq.connect('race.db')
cur = conn.cursor()

cur.execute("SELECT r.race_id, i.race_name, r.order_of_finish, r.odds \
             FROM race_result r INNER JOIN race_info i on r.race_id=i.id \
             WHERE r.odds<2.0")

rows = cur.fetchall()
for row in rows:
    print(row)

Jupyter Notebookのipynbファイルと同じ階層にrace.dbファイルを移し、読み込みます。
race.dbのうちレースのデータがrace_infoテーブル、race_resultテーブルに格納されているので、
欲しい情報を各テーブルから取得します。

※race_infoテーブル レースごとの情報が載っています

※race_resultテーブル 馬ごとの戦績が載っています

1倍台の人気で勝利した馬の期待値

オッズ別期待値(全クラス)

# 勝ち数
cur.execute("SELECT r.odds, count(r.race_id) \
             FROM race_result r \
             WHERE r.odds<2.0 AND r.order_of_finish='1' \
             GROUP BY r.odds ORDER BY r.odds ASC")
rows = cur.fetchall()
# 全レース 
cur.execute("SELECT r.odds, count(r.race_id) \
             FROM race_result r \
             WHERE r.odds<2.0 \
             GROUP BY r.odds ORDER BY r.odds")
rows2 = cur.fetchall()

# 期待値計算 もっと他に書きようありそう
try:
    t11 = rows[0][0] * rows[0][1] / (rows2[0][0] * rows2[0][1]) * 100
    t12 = rows[1][0] * rows[1][1] / (rows2[1][0] * rows2[1][1]) * 100
    t13 = rows[2][0] * rows[2][1] / (rows2[2][0] * rows2[2][1]) * 100
    t14 = rows[3][0] * rows[3][1] / (rows2[3][0] * rows2[3][1]) * 100
    t15 = rows[4][0] * rows[4][1] / (rows2[4][0] * rows2[4][1]) * 100
    t16 = rows[5][0] * rows[5][1] / (rows2[5][0] * rows2[5][1]) * 100
    t17 = rows[6][0] * rows[6][1] / (rows2[6][0] * rows2[6][1]) * 100
    t18 = rows[7][0] * rows[7][1] / (rows2[7][0] * rows2[7][1]) * 100
    t19 = rows[8][0] * rows[8][1] / (rows2[8][0] * rows2[8][1]) * 100
except:
    None

print('単勝1.1倍の馬券期待値は %d' %t11)
print('単勝1.2倍の馬券期待値は %d' %t12)
print('単勝1.3倍の馬券期待値は %d' %t13)
print('単勝1.4倍の馬券期待値は %d' %t14)
print('単勝1.5倍の馬券期待値は %d' %t15)
print('単勝1.6倍の馬券期待値は %d' %t16)
print('単勝1.7倍の馬券期待値は %d' %t17)
print('単勝1.8倍の馬券期待値は %d' %t18)
print('単勝1.9倍の馬券期待値は %d' %t19)

面白いことに、オッズが低いほど単勝期待値が高い(=1着になる可能性が高い)ことが分かりました。
やはり1.1倍ともなると歴史的名馬も多いからでしょうか。

似た条件で【オープンクラス以上(重賞含む)】に絞ると、1.1倍の期待値がさらに上昇しました。

OnlyOpenClass

cur.execute("SELECT r.odds, count(r.race_id) \
             FROM race_result r INNER JOIN race_info i on r.race_id=i.id \
             WHERE r.odds<2.0 AND r.order_of_finish='1' AND i.race_class like '%オープン%' \
             GROUP BY r.odds ORDER BY r.odds ASC")

人気別の成績を調べる

単勝1倍台の馬が出走するレースでは、どの馬が勝利することが多いのでしょうか？
2番人気や3番人気に妙味はあるのでしょうか？

上までの分析と違い、【単勝1倍台の馬がいるレースに限定】しなければ計算できないため、
WHERE ~ IN (SELECT ~~)の記法でサブクエリを使用しました。

ResultByPopularity

# 単勝1倍台の馬がいるレースのうち人気別勝ち数
cur.execute("SELECT r.popularity, count(r.race_id) \
             FROM race_result r \
             WHERE r.order_of_finish='1' AND r.race_id IN (SELECT race_id from race_result WHERE odds<2.0 AND popularity='1') \
             GROUP BY r.popularity ORDER BY r.popularity ASC")
rows = cur.fetchall()
# 単勝1倍台の馬がいる全レース 
cur.execute("SELECT count(r.race_id) FROM race_result r WHERE r.odds<2.0 AND r.popularity='1'")
rows2 = cur.fetchall()

for row in rows:
    print(row)
print(rows2[0][0])

全7,619レース中、約半数を1番人気が勝利しています。
2番人気は単勝6倍以上、3番人気は10倍近くつかないと期待値100を超えません。

オッズに頭数を掛け、レース数で割る形で期待値を計算しましたが、32と酷い有様でした。

まとめ

競馬場やダート/芝、馬齢、馬番、馬の脚質を細分化しなければ、オッズを見ても儲からない、というのが今回の結果でした。
また競馬には多様な馬券の種類があるため、【単勝1倍台の馬が出走するレースで最も期待値の高い馬券種はどれか？】など、
もっと深く分析できそうです。

Python(Jupiter Notebook)でSQLを抽出する要領はつかめたので、引き続き分析してみようと思います。

参考記事

netkeiba-scraperが2019年6月現在動くかの話(Ubuntu 18.04.2 LTS)

Instance Segmentation(物体検出+セグメンテーション) をするために
- 自前データをアノテーション
- Mask R-CNNを学習
ということを行なったのですが、他に役立つ記事が見当たらず苦労したので
メモ程度ですが僕が行なった手順を共有します。

Mask R-CNNについての解説は省略します。
以下を参考にしてください。
最新のRegion CNN(R-CNN)を用いた物体検出入門 ~物体検出とは? R-CNN, Fast R-CNN, Faster R-CNN, Mask R-CNN~

Mask R-CNNの実装は以下のレポジトリを利用しています。
https://github.com/facebookresearch/maskrcnn-benchmark

Labelmeによるデータ作成

https://github.com/wkentaro/labelme
基本的には上の README.mdの通りです
以下にざっとまとめます

インストール

$ pip install labelmeでも入るのですが、後ほどデータ変換でスクリプトを使うので git clone します

$ git clone https://github.com/wkentaro/labelme.git
$ cd labelme
$ pip install -e .

起動

クラス名を改行で羅列したclass.txtを作成してください。データの変換の際にエラーが出るかもなので一行目に__ignore__を追加します。
例:

classes.txt

__ignore__
person
bicycle
car
...

以下のコマンドでlabelmeを起動します

$ labelme <データフォルダのpath> --labels <classes.txtのpath> --nodata

アノテーション

以下サイトが参考になります。非常に簡単にアノテーションができます。
セマンティックセグメンテーションのアノテーションツールlabelme

データ形式変換

作成されたアノテーションデータ、元画像をMask R-CNN用に変換します。

$ cd labelme/examplts/instance_segmentation
$ ./labelme2coco.py <データフォルダのpath> <作成するディレクトリ名> --labels <classes.txt>

これによって
<作成するディレクトリ名>/JPEGImages ・・・画像が入ったディレクトリ
<作成するディレクトリ名>/annotations.json ・・・アノテーション情報が記されたjsonファイル
が作成されます

maskrcnnを学習させる

インストール

https://github.com/facebookresearch/maskrcnn-benchmark
上をREADME.mdにしたがってインストール

以下の記事が参考になります。
Pytorch1.1+MaskRCNNで自前データ訓練(1)

データ配置

データをmaskrcnnが読み込める位置に配置する

上で作成した
JPEGImages,
annotations.json
を
maskrcnn_benchmark/datasets/<新ディレクトリ名>/
に配置

データ登録

maskrcnn_benchmark/config/paths_catalog.py の DATASETS に以下を追加

COCO形式であることを読み込ませるために、"新データ名"にCOCOを含ませるようにしてください。

"新データ名" : {
    "img_dir" : "<新ディレクトリ名>"
    "ann_file" : "<新ディレクトリ名>/annotations.json"
} 

学習実行

以上の処理で、学習用 ,テスト用 のデータを登録してください。

以下にて学習を開始できるはずです。

$ python tools/train_net.py --config-file configs/e2e_mask_rcnn_R_50_FPN_1x.yaml DATASETS.TRAIN "(\"<新データ名(学習用)>\",)" DATASETS.TEST "(\"<新データ名(テスト用)>\",)"

--config-fileをconfigs/から指定することで、ネットワーク構造等のconfigを指定できます。
学習率やバッチサイズを変更したいときは、実行時に記すことで変更できます

例:

$ python tools/train_net.py --config-file configs/e2e_mask_rcnn_R_50_FPN_1x.yaml DATASETS.TRAIN "(\"<新データ名(学習用)>\",)" DATASETS.TEST "(\"<新データ名(テスト用)>\",)" SOLVER.BASE_LR 0.0025 SOLVER.IMS_PER_BATCH 2 TEST.IMS_PER_BATCH 1

SOLVER.BASE_LR : 学習スタート時の学習率 (逓減していきます )
SOLVER.IMS_PER_BATCH : 学習時バッチサイズ
TEST.IMS_PER_BATCH : テスト時バッチサイズ

全パラメータは
maskrcnn_benchmark/config/defaults.py
に書いてあります。

注意点

同じラベルの別物体が１つの物体として認識されてしまう

labelmeのデータ変換時に、デフォルトだとまとめて１つの物体として認識するようになっています。
別々に認識させたい場合は、labelme2coco.pyを以下にしたがって修正してください。
https://github.com/wkentaro/labelme/issues/419#issuecomment-511853597

セグメンテーションが一つの物体にしか行われない

学習の際にPytorchのバージョンによってラベルが全て一つの物体に対して作成されてしまうようです。

maskrcnn_benchmark/data/datasets/coco.py#L94
の挙動が予期せぬものとなっていることがあるので
target = target.clip_to_image(remove_empty=True) を
target = target.clip_to_image(remove_empty=False)
に変更してください。

　
　
以上になります。
ありがとうございました！

問題

https://atcoder.jp/contests/abc115/tasks/abc115_d

二度目の挑戦。解けて本当に嬉しかった。
この手の問題は他の競プロ系サイトでも出題しているので意外と大事。

方向性

問題文から再帰関数を用いるであろうことは想像難くない。問題はシュミレーターを作ると全てのバーガーの要素が膨大になってしまうので無理。必要な分だけ考えて算術で効率的にとく。

何が難しいか

問題の解釈は問題ない。問題は再帰をするための条件と戻り値を正しく決定できるかである。また、条件分岐が多いことも難易度をあげている。

解法

再帰問題のコツは状態位相を少ない値でモデリングすることだと感じた。つまり大事なことは以下の二つ
1. 再帰的に関数を呼び出すので、N,N-1,N-2...1,2の全てに成り立つ関数を作成すること。
2. 終了条件を考えること。

1. 再帰的に関数を呼び出すので、N,N-1,N-2...1,2の全てに成り立つ関数を作成すること。

今回の問題で必要となるのはダックスフンドの現在地と何次元のバーガーを参照しているかであるためその２つを引数にとる

1. 終了条件を考えること。

今回レベル０バーガーというわかりやすい終了条件があるのでこれを使う。

コード

以下コード。僕の解き方だと無駄に三つ引数を使っているので改善の余地あり。
```python
N, X = map(int, input().split())
patty = [1]
buns = [0]

for i in range(0, N):
patty.append(patty[i] * 2 + 1)
buns.append(buns[i] * 2 + 2)

print(patty)
print(buns)

burger_high = patty[N] + buns[N]
print("burger : ", burger_high)
print("burger/2 : ", burger_high/2)

def dfs(now_runrun, now_burger_high, dimension):
if dimension == 0:
return 1
## るんるんが一番下にいれば一つもパティは食べれない
elif now_runrun == 1:
return 0

## るんるんが真ん中にいたら、n - 1次元バーガー + 1を食べる
elif now_runrun == now_burger_high // 2 + 1:
    return patty[dimension - 1] + 1

## るんるんが一番上にいたら全てのパティを食べる
elif now_runrun == now_burger_high:
    return patty[dimension]


next_burger = now_burger_high // 2 - 1
next_dimension = dimension - 1

if now_runrun <= now_burger_high // 2:
    return dfs(now_runrun - 1, next_burger, next_dimension)
else:
    return dfs(now_runrun - (patty[next_dimension] + buns[next_dimension] + 2),
               next_burger, next_dimension) + patty[next_dimension] + 1

print(dfs(X, burger_high, N))
```

ざっくり要約

かなり間が空きましたが、以前書いた記事の続編的位置づけです。
今回作ったものはgithubに上げました。pipでインストールできる形にしてあるのは自分用です。

やりたかったこと

1. jsonで受け取ったデータ構造をちょこちょこ処理して、別のデータ構造でDynamoDBにputしようとした。
2. dictやlistを直接操作するコードが増えてうんざり。意味のあるデータ自身に振舞いを持たせたいというオブジェクト指向気取りな気分になる。
3. ならばclassに変換してしまおう。処理結果のクラスをdictに変換してしまおう。

実際にやったこと

1. 「dictやlistなどの汎用コンテナで作られた構造」を「任意のclass構造」に変換する。それと、その逆。¹
2. 変換ルールを定義するためのマッピングをdictで作って、それに従って変換するクラスを作りました。
3. 使用例をユニットテストで紹介します。

実際のコードをgithubに置いておきます。

さっそく作る

以前似たような物を作っていますが、コードも変わったし、時間も経ったので端折らずに1から書きます。

イメージ

例えば、変換元のソースとしてこんなdictがあるとします。dictの中にdictを含む構造です。

変換元のソース

src_dict = {
    'value' : 'AAA',
    'nested' : {
        'nested_value' : 'BBB'
    }
}

これを、こんなclassに変換したいとします。TastClassのself.nestedにNestedClassのインスタンスを持たせたいと考えています。

変換先のクラス

# クラスその1
class TestClass():
    def test_method(self):
        return 'assigned value: ' + self.value
# クラスその2 - その1にぶら下がるイメージ
class NestedTestClass:
    def test_method(self):
        return 'nested assigned value: ' + self.nested_value

二つのデータを結びつける情報

上の変換を行うには、コンテナのどの要素をどのclassに変換するか、というマッピングが必要だと思うので、こんな形のdictを考えてみた。

mapping = {
    '<MAPPING_ROOT>' : TestClass, # 最上位は名前がないので'<MAPPING_ROOT>'とする
    'nested' : NestedClass
}

[class/dictのキー] : [関数]のマッピングをdictで表現します。src_dictが指すdictそのものには名前がないので、代わりに<MAPPING_ROOT>をキーとします。関数としてコンストラクタを指定しています。
mappingに含まれない項目、この例だとsrc_dict['value']などは、そのまま変換先に設定します。

使い方

こんな風に使いたいと思っています。

usage

# コンストラクタでマッピングを取る
converter = ObjectConverter(mapping=mapping)
# 変換メソッドに変換元データを渡す
converted_class = converter.convert(src_dict)
# 変換されたクラスのメソッドを呼ぶ
converted_class.test_method()

実装

こんな風に作ってみました。

converter.pyとして作りましたが、長い。畳みます。

converter.py

class ObjectConverter:
    # 生成時にマッピング定義を受け取る
    def __init__(self, *, mapping):
        self.mapping = mapping

    # 変換の呼出しメソッド
    def convert(self, src):
        # 最上位の要素はマッピング'<root>'と必ずマッチする前提
        return self._convert_value('<MAPPING_ROOT>', self.mapping['<MAPPING_ROOT>'], src)

    # 値に従って処理方法を決める
    def _convert_value(self, key, func, value):
        # リストの場合、要素全てをfuncで変換していく
        if isinstance(value, (list, tuple)):
            return self._convert_sequence(key, func, value)

        # dictの場合、そのままキーと値を取り出す
        if isinstance(value, dict):
            return self._convert_dict(key, func, value)

        # classの場合__dict__を取り出してdictとして扱う
        if isinstance(value, object) and hasattr(value, '__dict__'):
            return self._convert_dict(key, func, value.__dict__)

        # どれにも該当しないものはそのまま返す
        return value

    # dictの中身を変換していく
    def _convert_dict(self, key, func, src):
        # _call_functionで生成したオブジェクトに中身を詰める
        return self._assign_dict(self._call_function(key, func, src), key, src)

    # mappingで指定されたオブジェクトの生成
    def _call_function(self, key, func, src):
        return func()

    # dictの中身を取り出して当てはめて行く
    def _assign_dict(self, dest, key, src):

        for srcKey, value in src.items():

            # keyがマッピングに定義されている
            if srcKey in self.mapping:
                func = self.mapping[srcKey]
                # マッピングされた関数を実行して結果をセットする
                self._set_value(dest, srcKey, self._convert_value(srcKey, func, value))

            # keyがマッピング定義にない物は、そのままセットする
            else:
                # ここで渡されたvalueの中にマッピング定義された値があっても無視する
                self._set_value(dest, srcKey, value)

        # createdにsrcの中身が反映された状態
        return dest

    # リストの処理
    def _convert_sequence(self, key, func, sequence):
        current = []
        for value in sequence:
            current.append(self._convert_value(key, func, value))
        return current

    # dictとclass両方に対応する値setter
    def _set_value(self, dest, key, value):
        if isinstance(dest, dict):
            dest[key] = value
        else:
            setattr(dest, key, value)

    # dict変換用インスタンスを得るユーティリティメソッド
    #
    @classmethod
    def dict_converter(cls, mapping, *, dict_object=dict):
        reverse_mapping = {}

        # マッピング先を全てdictにしてしまう
        for key in mapping.keys():
            reverse_mapping[key] = dict_object

        # dictに変換するためのインスタンス
        return ObjectConverter(mapping=reverse_mapping)

大体の解説

完全な仕様はソースを見てください。とはいえ、なんのことはない、mappingに含まれるキーと合致した値をただ走査するだけです。ざっくり言えばこんなことをしています。

• 最上位要素は<mapping_root>のキーと合致したとみなす。
• dictの中にdictがあったら再帰的に走査する。
• classの場合、dictを取り出してdictと同じように扱う。
• list/tupleを見つけたら、全ての要素がmappingのキーと合致したものとして走査する。
• 合致したキーに応じて、キーに対応する関数を呼び出して変換先を生成する。
• mappingに含まない値は変換先にそのまま設定する。変換先に応じて、setattrを使うか、dictの値として代入するか使い分ける。

クラスの中身に触れる

classを見つけた場合に__dict__を取り出してしまうことで、結局は全てdictを走査するだけの処理になります。__dict__に触れるのはできれば避けたいですが、今回は他の方法を使う労力を避けることにします。特殊なクラスを扱わない限り問題はないはずです。²

キーに反応しないケース

mappingに含まれない値はそのまま変換先のオブジェクトに設定されますが、このときの値がdictであったとして、その中にmappingに含まれる名前を持った値があっても、mappingの処理はされません。これは「mappingに含まれたdictの処理 or mappingに含まれue
dictの処理 」という場合分けが嫌なのと、そのような変換が必要になるデータ構造はあまり美しくないと思ったからそうしています。

class to dict変換

dict to class変換の後にclass to dict変換して元の形に戻したいケースのために、クラスメソッドdict_converterを用意して逆方向のコンバータが簡単に得られるようにしています。mapping上の変換先を全部dictにするだけなので簡単です。³

使い方の説明も兼ねたユニットテスト

長いので折りたたみます。

test_objectconverter.py

import unittest
import json
from objectonverter import ObjectConverter

# テスト用クラスその1
class TestClass():
    def test_method(self):
        return 'TestObject.test_method'

# テスト用クラスその2
class NestedTestClass:
    def test_method(self):
        return 'NestedObject.test_method'


class ClassConverterTest(unittest.TestCase):

    # ルートになるクラスのプロパティを設定するだけ
    def test_object_convert(self):
        dict_data = {
            'value1' : 'string value 1'
        }

        converter = ObjectConverter(mapping={'<MAPPING_ROOT>' : TestClass})
        result = converter.convert(dict_data)
        self.assertEqual(result.value1, 'string value 1')

        # 生成したクラスのメソッドを呼んでみる
        self.assertEqual(result.test_method(), 'TestObject.test_method')

    # ネストしたクラスを生成する
    def test_nested_object(self):
        # jsonのキーとクラスをマッピングするdict
        object_mapping = {
            '<MAPPING_ROOT>' : TestClass,
            'nested' : NestedTestClass
        }
        # 生成元のソース
        dict_data = {
            'value1' : 'string value 1',
            'nested' : {
                'value' : 'nested value 1'
            }
       }

        converter = ObjectConverter(mapping=object_mapping)
        result = converter.convert(dict_data)
        self.assertEqual(result.value1, 'string value 1')

        self.assertIsInstance(result.nested, NestedTestClass)
        self.assertEqual(result.nested.value, 'nested value 1')

    # マッピングを指定しない場合はただのdict
    def test_nested_dict(self):
        object_mapping = {
            '<MAPPING_ROOT>' : TestClass
        }

        # 生成元のソース
        dict_data = {
            'value1' : 'string value 1',
            'nested' : {
                'value' : 'nested value 1'
            }
        }

        converter = ObjectConverter(mapping = object_mapping)
        result = converter.convert(dict_data)
        self.assertEqual(result.value1, 'string value 1')
        self.assertIsInstance(result.nested, dict)
        self.assertEqual(result.nested['value'], 'nested value 1')

    # リストの処理
    def test_sequence(self):
        mapping = {
            '<MAPPING_ROOT>' : TestClass,
            'nestedObjects' : NestedTestClass,
        }
        source_dict = {
            "value1" : "string value 1",
            "nestedObjects" : [
                {'value' : '0'},
                {'value' : '1'},
                {'value' : '2'},
            ]
        }

        converter = ObjectConverter(mapping=mapping)
        result = converter.convert(source_dict)
        self.assertEqual(result.value1, 'string value 1')
        self.assertEqual(len(result.nestedObjects), 3)

        for i in range(3):
            self.assertIsInstance(result.nestedObjects[i], NestedTestClass)
            self.assertEqual(result.nestedObjects[i].value, str(i))

    # ルート要素自体がリストの場合
    def test_root_sequence(self):
        object_mapping = {
            '<MAPPING_ROOT>' : TestClass,
        }

        source_list = [
            {'value' : '0'},
            {'value' : '1'},
            {'value' : '2'},
        ]

        converter = ObjectConverter(mapping=object_mapping)
        result = converter.convert(source_list)

        self.assertIsInstance(result, list)
        self.assertEqual(len(result), 3)

        for i in range(3):
            self.assertIsInstance(result[i], TestClass)
            self.assertEqual(result[i].value, str(i))

    # json -> class -> json
    def test_json_to_class_to_json(self):
        # クラスからjsonの相互変換に使う関数
        def default_method(item):
            if isinstance(item, object) and hasattr(item, '__dict__'):
                return item.__dict__
            else:
                raise TypeError

        # jsonのキーとクラスをマッピングするdict
        object_mapping = {
            '<MAPPING_ROOT>' : TestClass,
            'nested' : NestedTestClass
        }
        # 生成元のソース - 比較の都合のため一行で
        string_data = '{"value1": "string value 1", "nested": {"value": "nested value 1"}}'
        dict_data = json.loads(string_data)

        converter = ObjectConverter(mapping=object_mapping)
        result = converter.convert(dict_data)
        dump_string = json.dumps(result, default=default_method)
        self.assertEqual(dump_string, string_data)

        # 再変換しても結果が同じこと
        result = converter.convert(json.loads(dump_string))
        self.assertEqual(result.value1, 'string value 1')
        self.assertIsInstance(result.nested, NestedTestClass)
        self.assertEqual(result.nested.value, 'nested value 1')

    # 変換 -> 逆変換
    def test_reverse_convert(self):
        dict_data = {
            'value1' : 'string value 1'
        }
        mapping = {'<MAPPING_ROOT>' : TestClass}

        converter = ObjectConverter(mapping=mapping)
        result = converter.convert(dict_data)
        self.assertEqual(result.value1, 'string value 1')

        # 逆変換コンバータを生成
        reverse_converter = ObjectConverter.dict_converter(mapping=mapping)
        reversed_result = reverse_converter.convert(result)
        self.assertEqual(result.value1, reversed_result['value1'])



if __name__ == '__main__':
    unittest.main()

解説

基本はまあ、見てもらえばわかるかなと
test_json_to_class_to_jsonという長い名前のテストケースがありますが、このクラスが元々jsonとの変換を強く意識していたゆえにこうなっています。

蛇足な言い訳

前回記事から半年以上過ぎていますが、実はやっと就職してですね…時間が取れなかったので遅くなりました。

---

1. 以下何度も「dict/list」と書くのは長いので、汎用コンテナと書きます。ついでに「クラス」というのも正確には「クラスのインスタンス」ですが、長いので「クラス」です。 ↩

2. 楽だからついやってしまうんですが、__dict__は裏口みたいなもので、__dict__から値を取り出すと__getattribute__が呼び出されなかったりするので、クラスの本来の意図とは異なる動作をするかも知れません。ここでは、そこまでは考えないでいきます。 ↩

3. いちおうdict以外の型にも対応するように書きましたが、使い道は思いつかない。 ↩

記事をご覧になってくださりありがとうございます！

どうも初めまして。2年間ぐらい組込み開発に携わっていましたが
転職後、環境的要因で精神崩壊→奇跡的に回復した、りゅうです。?

ほんだい

この記事は、複数のpng画像を昇順または降順に並べ替え一枚のgif画像を生成するプログラムについて載せている記事です。

ソースコード

gifmake.py

# -*- coding: utf-8 -*-
import sys
from PIL import Image
import glob

args = sys.argv

#Ascending (昇順)/Descending(降順)
if args[2] == 'A':
    value = False
elif args[2] == 'D':
    value = True
else:
    print('Enter A or D for the second argument!')

files = sorted(glob.glob('./*.png'),reverse=value)
images = list(map(lambda file: Image.open(file), files))

images[0].save(args[1]+'.gif', save_all=True, append_images=images[1:], duration=400, loop=0)

実行例

コマンドラインに下記のように入力するとgif画像が生成されます。

(base) C:\Users\UserName\Desktop>pyhton gifmake.py [生成するgif画像名(拡張子なし)]　[A/D(昇順/降順を指定する)]

降順

昇順

ソースコードのポイント

sorted()のreverseパラメータがTrueだと降順に、引数なしおよびFalseだと昇順にgif画像が生成できます。
最後の行のパラメータduration値を変更することで、gifアニメーション間隔を変更できます。

使った画像

いらすとや様

最後に

自分自身、組み込み系からWEB系にジョブチェンジを考えているので、
今後は、それに関する情報を発信すると思います。
よろしくお願いします✌

こんにちは。
時刻に対する floor 関数を作ってみました。計算単位として、下記例では 1 時間を整数で除算した値の 15 分を使っています。
"2020-01-01 00:05:05+09:00" => "2020-01-01 00:00:00+09:00"

import datetime

MINUTE = 60  # in seconds
HOUR = 3600  # in seconds
ndiv = 4  # in [1, 2, 3, 4, 5, 6, 10, 12, 15, 20, 30, 60]
interval = HOUR//ndiv  # in seconds
shift = 0  # in seconds

dt = datetime.datetime.strptime("2020-01-01 00:05:05+09:00", '%Y-%m-%d %H:%M:%S%z')
print(dt_floor(dt, interval, shift))  # => "2020-01-01 00:00:00+09:00"

def dt_floor(dt, interval, shift):
    interval_m = interval//MINUTE  # in minutes
    shift_dt = datetime.timedelta(seconds=shift)
    dt_shift = dt - shift_dt
    minute_floor = (dt_shift.minute//interval_m)*interval_m
    return dt_shift.replace(minute=minute_floor, second=0) + shift_dt

Python 自然言語処理(環境構築・前処理)

OS:Windows 10
想定環境：Windows環境で、社内のプロキシ等の問題で、
pip, apt-getができない場合の手動インストールでの環境構築方法

No	対応	URL
1	meCabｲﾝｽﾄｰﾙ(手動ｲﾝｽﾄｰﾙ可能)	https://toolmania.info/post-9815/
2	辞書DL(手動追加)	https://qiita.com/zincjp/items/c61c441426b9482b5a48
2	〃	流れ①git for Windows②NEologd辞書のダウンロードとコンパイル
3	前処理	Qiita記事
4	単語ごとの傾向分析	未調査

Python 自然言語処理(環境構築・前処理)

OS:Windows 10

No	対応	URL
1	meCabｲﾝｽﾄｰﾙ(手動ｲﾝｽﾄｰﾙ可能)	https://toolmania.info/post-9815/
2	辞書DL(手動？)	〃
2	〃	もしくはhttps://www.htmllifehack.xyz/entry/2018/11/23/223524
3	前処理	Qiita記事
4	単語ごとの傾向分析	未調査

Python 自然言語処理(環境構築・前処理)

OS:Windows 10
想定環境：Windows環境で、社内のプロキシ等の問題で、pipインストールが使用できない場合の手動インストールでの環境構築方法

No	対応	URL
1	meCabｲﾝｽﾄｰﾙ(手動ｲﾝｽﾄｰﾙ可能)	https://toolmania.info/post-9815/
2	辞書DL(手動？)	https://qiita.com/zincjp/items/c61c44142,6b9482b5a48
2	〃	流れ①git for Windows②NEologd辞書のダウンロードとコンパイル
3	前処理	Qiita記事
4	単語ごとの傾向分析	未調査

本記事について

競技プログラミングサイトの AtCoder にはプログラミング入門教材の「AtCoder Programming Guide for beginners (APG4b)」があります。プログラミング入門教材として非常に完成度が高く、競技プログラミングの主流言語である C++ が使われています。
そこで、本記事では APG4b を元に、それの Python 版を書きました。基本的には APG4b を読み進めて、Python 独自の部分は本記事を参考にして頂ければと思います。

大部分が APG4b を元にしているため、本記事が問題あるようでしたらすぐに削除します。

各節の見出しが本家へのリンクになっています。
節タイトルは本家に合わせているため、Pythonの用語と一部異なる部分もあります。

目次

1.00.はじめに
1.01.出力とコメント
1.02.プログラムの書き方とエラー
1.03.四則演算と優先順位
1.04.変数と型
1.05.実行順序と入力
1.06.if文・比較演算子・論理演算子
1.07.条件式の結果とbool型
1.08.変数のスコープ
1.09.複合代入演算子
1.10.while文
1.11.for文・break・continue
1.12.文字列（と文字）
1.13.リスト（配列）
1.14.標準ライブラリの組み込み関数(STLの関数)
1.15.関数
おわりに

1.00.はじめに

第1章について

第1章では、基本的な文法について説明します。

プログラミング言語

本家 APG4b では C++ というプログラミング言語を扱っています。この記事では Python というプログラミング言語を扱います。

プログラムの実行方法

手元に Python の環境構築をするのも良いですが、AtCoder のコードテストでも十分書くことができます。

問題

提出練習

本記事には Python 版のコードを載せますが、問題への提出は本家の提出欄を使用してください。提出欄は、本家のページの一番下にあります。

まずは、提出欄の「言語」を「Python3 (3.4.3)」に変更してください。
変更したら、次のコードをコピー&ペーストしてみましょう。

print("Hello, world!")

ペーストできたら、「提出」ボタンを押してください。
ページが切り替わり、　結果欄が緑色の「AC」になっていれば提出成功です。

1.01.出力とコメント

キーポイント

• Python のコードは、処理内容を直接書くことができる
  • main 関数を書く必要がない。書くこともできるが、競プロのような小規模なコードの際は書かなくても大丈夫
• print("文字列") で文字列を出力できる
• # や """ """ でコメントを書ける

書き方	コメントになる場所
#	同じ行の # を書いた場所より後
""" """	""" と """ の間

プログラムの基本形

次のプログラムは何もしないプログラムです。

つまり、C++ と違って main 関数等を書く必要がありません。処理内容を直接書くだけでプログラムが動きます。
main 関数を書くこともできますが、競技プログラミングのような小規模の場合は書かなくても大丈夫です。

出力

最初に提出したプログラムを見てみましょう。
このプログラムは「Hello, world!」という文字列を出力するプログラムです。

print("Hello, world!")

実行結果

Hello, world!

print()

Python で文字列を出力するには print() を使います。
出力する文字列を指定している部分は "Hello, world!" の部分です。print() の () 内に書くことで、文字列を出力することができます。
Python プログラムの中で文字列を扱う場合、" " で囲う必要があります。また、自動で文末に改行が行われます。

行の終わり

C++ では行末に ; が必要ですが、Python では何も書く必要がありません。（一応書いても問題なく動きます）

別の文字列の出力

別の文字列を出力したい場合、次のように " " の中身を変えます。

print("こんにちは世界")

出力結果

こんにちは世界

複数の出力

出力を複数回行うこともできます。

print("a")
print("b")
print("c", "d")

実行結果

a
b
c d

先ほども書いたように、Python の print() では文末に自動で改行が行われます。そのため、a の次の行に b が出力されます。
次に、, 区切りで複数書くことで、c d のように空白区切りで出力されます。

数値の出力

数値を出力するときは、" " を使わずに、直接書くことでも出力できます。

print(2525)

実行結果

2525

コメント

コメントはプログラムの動作を説明するためのメモ書きを残すためのもので、書いてもプログラムの動作に影響はありません。
Python におけるコメントの例を見てみましょう。

print("Hello, world!")  # Hello, world! と表示
""" ここも
コメント """

実行結果

Hello, world!

コメントには二種類の書き方があります。

書き方	コメントになる場所
#	同じ行の # を書いた場所より後
""" """	""" と """ の間

全角文字

Python では C++ と違い、プログラム中に「全角文字」が含まれていても基本的には問題なく動作します。
しかし、読みづらくなるため「半角文字」で書くことを推奨します。

問題

以下のリンク先に問題文が載っています。
EX1.コードテストと出力の練習

サンプルプログラム

print("Hello, world!")
print("Hello, AtCoder!")
print("Hello, Python!")

サンプルプログラムの実行結果

Hello, world!
Hello, AtCoder!
Hello, Python!

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.02.プログラムの書き方とエラー

キーポイント

• Python はスペース・改行・インデントに意味がある
• Python には「PEP8」というコーディング規約がある
• Python はインタプリタ型言語であるため、コンパイルエラーは起こらない

プログラムの書き方

プログラム中のスペースと改行、およびインデントについて説明します。また、Python のコーディング規約である PEP8 についても説明します。

スペースと改行

Python では、スペースは省略することができますが、改行には意味があるため省略できません。

C++ では ; が行の終わりを意味しますが、Python では改行が行の終わりを意味します。

インデント

C++ ではインデントは読みやすさのために行いますが、Python の場合はインデントにも意味があります。

後述の if 文を例に C++ と Python の違いを見てみましょう。

C++（インデントあり）

#include <bits/stdc++.h>
using namespace std;

int main() {
    if (条件式) {
        処理
    }
}

C++（インデントなし）

#include <bits/stdc++.h>
using namespace std;

int main() {
if (条件式) {
処理
}
}

C++ の場合、上記のように { } 内でインデントを行っても行わなくても動作に違いはありません。

Python

if 条件式:
    処理

Python では { } の代わりに : とインデントを用いて if 文の中であることを表現するため、インデントが必須となります。

PEP8

PEP8 とは、Python のコーディング規約です。コーディング規約とは読みやすさのために定められたルールのことです。

PEP8 を守らなくてもプログラムは問題なく動作しますが、守ることで読みやすいプログラムを書くことができます。

すべてを紹介すると長くなるため、ここではそのうちのいくつかを紹介します。

• インデントは半角スペース4つ
• 1行の長さは最大79文字
• 余計なスペースは入れない

詳細は https://pep8-ja.readthedocs.io/ja/latest/ に書いてあります。

プログラムのエラー

基本的には本家 APG4b に書いてある通りですが、Python はインタプリタ型言語であるため、コンパイルエラーは起きません。

インタプリタ型言語とは、C++ のようにコンパイルを行わず、1文ずつ実行されていきます。そのため、文法の間違いがあった場合はコンパイルエラーではなく実行時エラーになります。

問題

以下のリンク先に問題文が載っています。
EX2.エラーの修正

A君が書いたプログラム

print("いつも)
print("2525"
print(AtCoderくん)

標準エラー出力

  File "./Main.py", line 1
    print("いつも)
               ^
SyntaxError: EOL while scanning string literal

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.03.四則演算と優先順位

キーポイント

演算子	計算内容
+	足し算
-	引き算
*	掛け算
/	割り算
//	切り捨て割り算
%	割った余り
**	冪乗

四則演算

Python プログラムで簡単な計算をする方法を見ていきましょう。
次のプログラムは上から順に、「足し算」「引き算」「掛け算」「割り算」「切り捨て割り算」を行っています。

print(1 + 1)  # 2
print(3 - 4)  # -1
print(2 * 3)  # 6
print(7 / 3)  # 2.3333333333333335
print(7 // 3)  # 2

実行結果

2
-1
6
2.3333333333333335
2

これらの記号 +, -, *, / のことを算術演算子といいます。
3 - 4 が -1 になっている通り、負の値も計算できます。
* が掛け算で、 / が「割り算」です。

Python では / は普通の割り算で、結果は小数になります。小数点以下が切り捨てされる割り算は // で行います。
また、 // は常にマイナス無限大方向に丸められます。C++ の / も切り捨て割り算ですが、C++ の / は常に0方向に丸められるため、C++ の / と Python の // は違います。Python で常に0方向に丸めたいときは、int(a / b) のように書きましょう。

print(10 // 3, -10 // 3)
print(int(10 / 3), int(-10 / 3))

実行結果

3 -4
3 -3

剰余演算

% は「割ったときの余り」を計算します。

print(7 % 3)  # 1
print(4 % 5)  # 4

実行結果

1
4

$7 ÷ 3 = 2$ あまり $1$
$4 ÷ 5 = 0$ あまり $4$
となるため、このプログラムの出力は 1 と 4 になります。

冪乗演算

Python には冪乗の演算子も用意されています。冪乗とは、 $a ^ b$ と表される数です。

print(3 ** 4)  # 81
print(25 ** 0.5)  # 5.0
print(1.5 ** 2)  # 2.25

実行結果

81
5.0
2.25

上記のように、 a ** b で $a ^ b$ が計算できます。また、 25 ** 0.5 や 1.5 ** 2 のように小数の計算もできます。

演算子の優先順位

四則演算の優先順位は C++ と同じため、本家を参考にしてください。

問題

以下のリンク先に問題文が載っています。
EX3.計算問題

サンプルプログラム

print(""" ここに式を書く """)

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.04.変数と型

キーポイント

• 変数はメモ
• = は代入
• 「データの種類」のことを型という

型	書き込むデータの種類
int	整数
float	小数
str	文字列

変数

変数という機能について見ていきましょう。変数は「メモ」だと考えてください。

例を見てみましょう。

name = 10

print(name)      # 10
print(name + 2)  # 10 + 2 → 12
print(name * 3)  # 10 * 3 → 30 

実行結果

10
12
30

宣言と代入

Python の場合、宣言と代入は同時に行います。宣言が必要ないと言った方が正確かもしれません。

name = 10

この部分で、「name」という変数を宣言して、その中に 10 を代入しています。
= の記号は「代入（書き込み）」の意味であって、「等しい」という意味ではないことに注意してください。

「型」や「値」についての説明は本家を参照してください。

C++ の場合は int と書いて、変数の型が「整数」であることを明示する必要がありますが、Python の場合は代入する 10 が整数であるため、自動で name の型を int にしてくれます。

読み込み

プログラムの最後の3行で変数にメモした値を読み込んで出力しています。

print(name)      # 10
print(name + 2)  # 10 + 2 → 12
print(name * 3)  # 10 * 3 → 30 

変数はコピーされる

変数1 = 変数2 と書いた場合、変数の値そのものがコピーされます。
その後にどちらかの変数の値が変更されても、もう片方の変数は影響を受けません。

a = 10

b = a
a = 5

print(a)  # 5
print(b)  # 10

実行結果

5
10

変数 b が 10 のままであることに注意してください。
処理内容は本家の方にわかりやすく図で説明されています。Python の場合は宣言と代入が同時に行われるため、b の宣言は b = a の部分で行われます。

変数を同時に代入

変数の代入時に , を間に入れることで、1行で複数の変数の代入が行えます。

a, b = 10, 5

print(a)
print(b)

実行結果

10
5

上のプログラムは次のように書いた場合と同じ意味になります。

a = 10
b = 5

変数名のルール

変数名は基本的に自由につけることができますが、一部の名前を変数名にしようとするとエラーになります。

利用できない変数名

以下の条件に該当する名前は変数名にできません。

• 数字で始まる名前
• _ 以外の記号が使われている名前
• キーワード（Python が使っている一部の単語）

以下は変数名にできない名前の例です。本家の例で使われている int は、Python では変数名として使うことができます（……推奨はしませんが）。

100hello = 10  # 数字で始まる名前にはできない
na+me = "AtCoder"  # 変数名に+を使うことはできない
not = 100  # not はキーワードなので変数名にできない

以下のような名前は変数名にできます。

hello10 = 10  # 2文字目以降は数字にできる
hello_world = "Hello, world"  # _ は変数名に使える
変数1 = 1  # 漢字
へんすう2 = 2  # ひらがな

Python の場合は C++ と違って、漢字やひらがなも変数名に使うことができます。
Python のキーワードについては、検索すると一覧が出てきます。

型

int 以外にも Python には様々な型があります。ここでは重要な3つの型だけを紹介します。
C++ では小数は double ですが、Python では float になります。同様に文字列は str です。

型	書き込むデータの種類
int	整数
float	小数（実数）
str	文字列

i = 10  # 10 は整数
f = 0.5  # 0.5 は小数
s = "Hello"  # "Hello" は文字列

print(i, type(i))  # type(変数) で変数の型がわかる
print(f, type(f))
print(s, type(s))

実行結果

10 <class 'int'>
0.5 <class 'float'>
Hello <class 'str'>

異なる型同士の計算

異なる型同士の計算では型変換が行われます。
例えば、int 型と float 型の計算結果は float 型になります。

ただし、変換できない型同士の計算はエラーになります。

i = 30
d = 1.5
s = "Hello"

print(i + d, type(i + d))  # 31.5
print(i * d, type(i * d))  # 45.0

"""
以下の処理はエラー
print(s + i)  # str型とint型の足し算
print(s + d)  # str型とfloat型の足し算
"""

実行結果

31.5 <class 'float'>
45.0 <class 'float'>

なお、Python の場合は str型 * int型 の計算は可能です。

i = 5
s = "Hello"

print(s * i)  # "Hello" * 5 → ???

上のプログラムの結果はどうなるでしょうか。実行結果を見てみましょう。

実行結果

HelloHelloHelloHelloHello

"Hello" が5回繰り返された文字列になります。

異なる型同士の代入

Python の場合、変数の型は中に何が入っているかによって決まります。よって、次のプログラムは正常に動作します。

i = 10
s = "Hello"

i = s

print(i)
print(type(i))

実行結果

Hello
<class 'str'>

問題

以下のリンク先に問題文が載っています。
EX4.◯年は何秒？

サンプルプログラム

# 1年の秒数
seconds = 365 * 24 * 60 * 60

# 以下のコメント """ """ を消して追記する
print(""" 1年は何秒か """)
print(""" 2年は何秒か """)
print(""" 5年は何秒か """)
print(""" 10年は何秒か """)

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.05.実行順序と入力

キーポイント

• プログラムは上から下へ順番に実行される
• 変数 = input() で入力を受け取ることができる
• スペースと改行で区切られて入力される

プログラムの実行順序

基本的にプログラムは上から下へ順番に実行されます。

次のプログラムを見てください。

name = 10

print(name)  # 10

name = 5

print(name)  # 5

実行結果

10
5

基本的な構造は本家と同様なので、実行の様子については本家のスライドを参照してください。

入力

プログラムの実行時にデータの入力を受け取る方法を見ていきましょう。
「入力機能」を使うことにより、プログラムを書き換えなくても様々な計算を行えるようになります。

入力を受け取るには input() を使います。
次のプログラムは、入力として受け取った数値を10倍にして出力するプログラムです。

a = int(input())

print(a * 10)

入力

5

実行結果

50

input() は1行の入力を文字列として受け取ります。そのため、int 型として受け取るためには int() によって int 型に変換してあげる必要があります。

a = input()

print(a, type(a))

a = int(a)  # int型に変換

print(a, type(a))

入力

5

実行結果

5 <class 'str'>
5 <class 'int'>

整数以外のデータの入力

整数以外のデータを受け取りたい時は、同様に必要な型に変換する必要があります。

text = input()
f = float(input())

print(text, f)

入力

Hello
1.5

実行結果

Hello 1.5

空白区切りの入力

前述のように、input() は1行の入力を文字列として受け取ります。

a = input()

print(a)
print(type(a))

入力

10 20 30

実行結果

10 20 30
<class 'str'>

そのため、空白区切りの入力をただ受け取ると、上のように変数 a に "10 20 30"という文字列として代入されてしまいます。

空白で分割

そこで、input() の後ろに .split() をつけて文字列を分解する必要があります。

a, b, c = input().split()

print(a)
print(type(a))

入力

10 20 30

実行結果

10
<class 'str'>

こうすることで "10 20 30" が空白区切りで分割されて、"10", "20", "30" の3つにすることができました。

整数に変換

あとは、これまでと同様に int() を使って整数に変換してあげれば、空白区切りの入力を整数として受け取ることができます。

a, b, c = input().split()

a = int(a)
b = int(b)
c = int(c)

print(a)
print(type(a))

入力

10 20 30

実行結果

10
<class 'int'>

上のプログラムでは int 型への変換を変数の数だけ毎回書きましたが、これを1行で書くこともできます。

a, b, c = map(int, input().split())

print(a)
print(type(a))

入力

10 20 30

実行結果

10
<class 'int'>

map(型, input().split()) と書くことで、分割された全ての文字列を同時に指定した型に変換することができます。

複数行の入力

input() は1行の入力を受け取るものなので、入力が複数行ある場合はその行数分書く必要があります。

s = input()
a = int(input())

print(s, a)

入力

Hello
10

実行結果

Hello 10

問題

以下のリンク先に問題文が載っています。
EX5.A足すB問題

サンプルプログラム

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.06.if文・比較演算子・論理演算子

キーポイント

• if文を使うと「ある条件が正しいときだけ処理をする」というプログラムを書ける
• else句を使うと「条件が正しくなかったとき」の処理を書ける

if 条件式1:
    処理1
elif 条件式2:
    処理2
else:
    処理3

• 比較演算子

演算子	意味
x == y	x と y は等しい
x != y	x と y は等しくない
x > y	x は y より大きい
x < y	x は y より小さい
x >= y	x は y 以上
x <= y	x は y 以下

• 論理演算子

演算子	意味	真になるとき
not 条件式	条件式の結果の反転	条件式が偽
条件式1 and 条件式2	条件式1が真 かつ 条件式2が真	条件式1と条件式のどちらも真
条件式 or 条件式2	条件式1が真 または 条件式2が真	条件式1と条件式2の少なくとも片方が真

if文

if文を使うと、ある条件が正しいときだけ処理をするというプログラムが書けるようになります。
書き方は次のようになります。

if 条件式:
    処理

条件式が正しいとき、: 以降のインデントが1つ下がった部分の処理が実行され、条件式が正しくないとき、処理は飛ばされます。

次の例では、入力の値が10より小さければ「xは10より小さい」と出力した後「終了」と出力します。また、入力の値が10より小さくなければ「終了」とだけ出力されます。

x = int(input())

if x < 10:
    print("xは10より小さい")

print("終了")

入力1

5

実行結果1

xは10より小さい
終了

入力2

15

実行結果2

終了

この例では、まず変数 x に整数のデータを入力しています。

x = int(input())

重要なのはその後です。

if x < 10:
    print("xは10より小さい")

この部分は、「もし x < 10 （xが10より小さい）なら、 xは10より小さい と出力する」という意味になります。
最後に print("終了") を実行して 終了 と出力し、プログラムは終了します。

xが10より小さくない場合は、

    print("xは10より小さい")

の処理は飛ばされます。そのため、2つ目の実行例では 終了 とだけ出力されています。

if文のように、何かの条件で処理が実行されることを条件分岐といいます。
また、「条件式が正しい」ことを条件式が真、「条件式が正しくない」ことを条件式が偽といいます。

比較演算子

Python の比較演算子は C++ と同じため、この項は本家を参照してください。

次のプログラムは、入力された整数値がどんな条件を満たしているかを出力するプログラムです。

x = int(input())

if x < 10:
    print("xは10より小さい")

if x >= 20:
    print("xは20以上")

if x == 5:
    print("xは5")

if x != 100:
    print("xは100ではない")

print("終了")

入力1

5

実行結果1

xは10より小さい
xは5
xは100ではない
終了

入力2

100

実行結果2

xは20以上
終了

論理演算子

条件式の中にはもっと複雑な条件を書くこともできます。そのためには論理演算子を使います。

演算子	意味	真になるとき
not 条件式	条件式の結果の反転	条件式が偽
条件式1 and 条件式2	条件式1が真 かつ 条件式2が真	条件式1と条件式のどちらも真
条件式 or 条件式2	条件式1が真 または 条件式2が真	条件式1と条件式2の少なくとも片方が真

x, y = map(int, input().split())

if not x == y:
    print("xとyは等しくない")

if x == 10 and y == 10:
    print("xとyは10")

if x == 0 or y == 0:
    print("xかyは0")

print("終了")

入力1

2 3

実行結果1

xとyは等しくない
終了

入力2

10 10

実行結果2

xとyは10
終了

入力3

0 8

実行結果3

xとyは等しくない
xかyは0
終了

「前の条件が真でないとき」の処理

else句

else句は、if文の後に書くことで、「if文の条件が偽のとき」に処理を行えるようになります。
書き方は次のようになります。

if 条件式1:
    処理1
else:
    処理2

次のプログラムは、入力の値が10より小さければ「xは10より小さい」と出力し、そうでなければ「xは10より小さくない」と出力します。

x = int(input())

if x < 10:
    print("xは10より小さい")
else:
    print("xは10より小さくない")

入力1

5

実行結果1

xは10より小さい

入力2

15

実行結果2

xは10より小さくない

elif

elif では、「『前のif文の条件が偽』かつ『elifの条件が真』」のときに処理が行われます。
書き方は次のようになります。

if 条件式1:
    処理1
elif 条件式2:
    処理2

処理2が実行されるのは、「条件式1が偽 かつ 条件式2が真」のときになります。
例を見てみましょう。

x = int(input())

if x < 10:
    print("xは10より小さい")
elif x > 20:
    print("xは10より小さくなくて、20より大きい")
elif x == 15:
    print("xは10より小さくなくて、20より大きくなくて、15である")
else:
    print("xは10より小さくなくて、20より大きくなくて、15でもない")

入力1

5

実行結果1

xは10より小さい

入力2

30

実行結果2

xは10より小さくなくて、20より大きい

入力3

15

実行結果3

xは10より小さくなくて、20より大きくなくて、15である

入力4

13

実行結果4

xは10より小さくなくて、20より大きくなくて、15でもない

この例のように、elif の後に続けて elif や else を書くこともできます。

問題

以下のリンク先に問題文が載っています。
EX6.電卓をつくろう

サンプルプログラム

a, op, b = input().split()
a = int(a)
b = int(b)

if op == "+":
    print(a + b)

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.07.条件式の結果とbool型

キーポイント

• 条件式の結果は真のときに True に、偽のときに False になる
• int型では、True を 1 で、False を 0 で表す
• bool型は True と Falseだけが入る型

	int型の表現	bool型の表現
真	1	True
偽	0	False

条件式の結果

Python では、真のことを True で表現し、偽のことを False で表現します。C++ と違って先頭が大文字なことに注意してください。
条件式の「計算結果」も真のときは True 、偽のときは False になります。

次のプログラムは条件式の結果をそのまま出力し、真のときと偽のときでどのような値を取るか確認しています。

print(5 < 10)
print(5 > 10)

実行結果

True
False

出力を見てみると、条件が真のときは True 、偽のときは False になっていることがわかります。

TrueとFalse

Python の場合、通常は真と偽を True と False で表すのでこのタイトルは正しくない気もしますが、本家に合わせます。

条件式の部分に直接 True や False を書くこともできます。次のプログラムはその例です。

# Trueは真を表すので、helloと出力される
if True:
    print("hello")

# Falseは偽を表すのでこのifの中は実行されない
if False:
    print("world")

実行結果

hello

また、int型においては True を 1、False を 0 で表します。

print(int(True))
print(int(False))

実行結果

1
0

bool型

bool型というデータ型があります。この型の変数には True または False だけが入ります。

x = int(input())

a = True
b = x < 10  # xが10未満のときTrue そうでないときFalseになる
c = False

if a and b:
    print("hello")

if c:
    print("world")

入力

3

実行結果

hello

このように、条件式の結果など、真偽のデータを変数で扱いたい場合は bool 型を使います。
いままで if 条件式 と書いていましたが、基本的には if bool型の値 ということになります。

ここまでの話をまとめたのが次の表です。

	int型の表現	bool型の表現
真	1	True
偽	0	False

bool型を使う場面

本家を参照してください。

問題

以下のリンク先に問題文が載っています。
EX7.bool値パズル

サンプルプログラム

# 変数a, b, cにTrueまたはFalseを代入してAtCoderと出力されるようにする
a = # True または False
b = # True または False
c = # True または False

# ここから先は変更しないこと

if a:
    print("At", end="")  # end="" と書くと末尾改行がされなくなる
else:
    print("Yo", end="")

if (not a) and b:
    print("Bo", end="")
elif (not b) and c:
    print("Co", end="")

if a and b and c:
    print("foo!")
elif True and False:
    print("yeah!")
elif (not a) or c:
    print("der")

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.08.変数のスコープ

キーポイント

• インデントが共通の部分をブロックという
• 変数が使える範囲のことをスコープという
• 通常、変数のスコープは「変数が宣言されてからそのブロックが終わるまで」
  • Pythonの場合、if文などではスコープが作られず、ブロック外でも使うことができる

変数のスコープ

今までif文の後ろに : を書いて以下の行でインデントを行なってきました。このインデントがある部分のことをブロックといいます。

本家には「
あるブロックの中で宣言した変数は、それより内側のブロックでしか使えないというルールがあります。そして、その変数が使える範囲のことをスコープといいます。
」と書かれています。
Python の場合 C++ とは異なっていて、if文などの場合はスコープが作られず、ブロック内で宣言した変数をブロック外でも使うことができます。

具体例を見てみましょう。

x = 5

if x == 5:
    y = 10
    print(x + y)

print(x)
print(y)

実行結果

15
5
10

これは本家に載っているプログラムと同内容のものです。
本家では C++ を扱っているため、これはエラーが出る例として載っていますが、Python では上のようにエラーは発生せず、正常に動作します。

スコープについての詳しい話は本家を参照してください。

問題

以下のリンク先に問題文が載っています。
EX8.たこ焼きセット

A君が書いたプログラム

p = int(input())

# パターン1
if p == 1:
    price = int(input())

# パターン2
if p == 2:
    text = input()
    price = int(input())

n = int(input())

print(text + "!")
print(price * n)

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.09.複合代入演算子

キーポイント

• x = x + y は x += y のように短く書ける
• Python にはインクリメントもデクリメントもない

複合代入演算子

x = x + 1 のように、同じ変数名が2回現れる代入文では、複合代入演算子を使うとより短く書くことができます。

次のプログラムは、変数 x に (1 + 2) を足して出力するだけのプログラムです。

x = 5
x += 1 + 2
print(x)  # 8

実行結果

8

x += 1 + 2

は、

x = x + (1 + 2)

と同じ意味になります。

+=以外の複合代入演算子

他の算術演算子についても同様のことができます。

a = 5
a -= 2
print(a)  # 3

b = 3
b *= 1 + 2
print(b)  # 9

c = 5
c /= 2
print(c)  # 2.5

d = 5
d //= 2
print(d)  # 2

e = 5
e %= 2
print(e)  # 1

f = 3
f **= 4
print(f)  # 81

実行結果

3
9
2.5
2
1
81

インクリメントとデクリメント

C++ にはインクリメントとデクリメントがありますが、Python にはありません。
インクリメントについて知りたい場合は本家を参照してください。

問題

以下のリンク先に問題文が載っています。
EX9.複合代入演算子を使おう

サンプルプログラム

x, a, b = map(int, input().split())

# 1.の出力
x += 1
print(x)

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.10.while文

キーポイント

• while文を使うと繰り返し処理ができる
• 条件式が真のとき処理を繰り返す

while 条件式:
    処理

• 「$N$回カウントする」というプログラムを書く場合、「カウンタ変数を0からはじめ、カウンタ変数が$N$より小さいときにループ」という形式で書く

i = 0  # カウンタ変数
while i < N:
    処理
    i += 1

while文

while文を使うと、プログラムの機能の中でも非常に重要な「繰り返し処理」（ループ処理）を行うことができます。

無限ループ

次のプログラムは、「"Hello" と出力して改行した後、"AtCoder" と出力する処理」を無限に繰り返すプログラムです。

while True:
    print("Hello")
    print("AtCoder")

実行結果

Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
Hello
AtCoder
...(無限に続く)

while文は次のように書き、条件式が真のとき処理を繰り返し続けます。

while 条件式:
    処理

先のプログラムでは条件式の部分に True と書いているため、無限に処理を繰り返し続けます。
このように、無限に繰り返し続けることを無限ループと言います。

1つずつカウントする

次のプログラムは、1から順に整数を出力し続けます。

i = 1

while True:
    print(i)
    i += 1  # ループのたびに1増やす

実行結果

1
2
3
4
5
6
7
8
...(無限に1ずつ増えていく)

ループ回数の指定

1ずつカウントするプログラムを「1から5までの数を出力するプログラム」に変える場合、次のようにします。

i = 1

# i が 5 以下の間だけループ
while i <= 5:
    print(i)
    i += 1

実行結果

1
2
3
4
5

カウンタ変数は0からN未満まで

5回 "Hello" と出力されるプログラムを考えます。
まず一般的でない書き方（やめておいた方が良い書き方）を紹介し、次に一般的な書き方（推奨される書き方）を紹介します。

一般的でない書き方

# i を 1 からはじめる
i = 1

# i が 5 以下の間だけループ
while i <= 5:
    print("Hello")
    i += 1

実行結果

Hello
Hello
Hello
Hello
Hello

「$N$回処理をする」というプログラムをwhile文で書く場合、今までは「i を1からはじめ、$N$以下の間ループする」という形式で書いてきました。

i = 1
while i <= N:
    処理
    i += 1

この形式は一見わかりやすいと感じるかもしれません。
しかし、この書き方はあまり一般的ではなく、次のように書いた方がいいです。

一般的な書き方

# i を 0 からはじめる
i = 0

# i が 5 未満の間だけループ
while i < 5:
    print("Hello")
    i += 1

実行結果

Hello
Hello
Hello
Hello
Hello

「$N$回処理する」というプログラムを書く場合、次のような「i を0からはじめ、i が$N$より小さいときにループする」という形式で書くのが一般的です。

i = 0
while i < N:
    処理
    i += 1

最初は分かりづらく感じるかもしれませんが、こう書いた方がプログラムをシンプルに書けることが後々増えてくるので、慣れるようにしましょう。

なお、このプログラムの変数 i のように「何度目のループか」を管理する変数のことをカウンタ変数と呼ぶことがあります。カウンタ変数は基本的に i を使い、i が使えない場合はj, k, l, ...と名前をつけていくのが一般的です。

応用例

$N$人の合計点を求めるプログラムを作ってみましょう。
次のプログラムは「入力の個数$N$」と「点数を表す$N$個の整数」を入力で受け取り、点数の合計を出力します。

n = int(input())

sum = 0  # 合計点を表す変数
i = 0    # カウンタ変数

while i < n:
    x = int(input())
    sum += x
    i += 1

print(sum)

入力

3
1
10
100

実行結果

111

合計点を表す変数 sum を作っておき、ループするたびに入力変数 x に入れ、sum に足しています。
本家の方に処理内容を解説したスライドがあります。

問題

以下のリンク先に問題文が載っています。
EX10.棒グラフの出力

print() だけだと末尾に自動で改行が入ってしまうため、print(出力内容, end="") とすることで末尾改行を行わないことができます。

サンプルプログラム

a, b = map(int, input().split())

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.11.for文・break・continue

キーポイント

• for文は繰り返し処理でよくあるパターンをwhile文より短く書くための構文
• 列の中身が先頭から順にカウンタ変数に代入される

for カウンタ変数 in 列:
    処理

• $N$回の繰り返し処理は次のfor文で書くのが一般的

for i in range(N):
    処理

• breakを使うとループを途中で抜けられる
• continueを使うと後の処理を飛ばして次のループへ行ける

for文

for文は「$N$回処理する」というような繰り返し処理でよくあるパターンをwhile文より短く書くための構文です。

3回繰り返すプログラムをwhile文とfor文で書くと次のようになります。

j = 0
while j < 3:
    print("Hello while:", j)
    j += 1

for i in range(3):
    print("Hello for:", i)

実行結果

Hello while: 0
Hello while: 1
Hello while: 2
Hello for: 0
Hello for: 1
Hello for: 2

for文は次のように書きます。

for カウンタ変数 in 列:
    処理

列について詳しくは後の節で解説しますが、[3, 1, 4, 1, 5] のような数列（リスト）や、"abcdef" のような文字列があります。
次のプログラムを見てみましょう。

for i in [3, 1, 4, 1, 5]:
    print("i:", i)

実行結果

i: 3
i: 1
i: 4
i: 1
i: 5

リスト [3, 1, 4, 1, 5] の中身が先頭から順に取り出されて、i に代入されているのがわかります。

N回の繰り返し処理

「$N$回処理をする」というような繰り返し処理をしたいときは、range() を使うと楽です。range(a, b) と書くことで、[a, a+1, a+2, ..., b-1] の数列が生成されます。

for i in range(0, 5):  # [0, 1, 2, 3, 4]
    print(i)

実行結果

0
1
2
3
4

range(a, b) の a は0のときに省略することができ、 range(b) と書くことができます。よって、次の2つの書き方は同じ意味になります。

for i in range(0, 5):
    print(i)

for i in range(5):
    print(i)

実行結果

0
1
2
3
4
0
1
2
3
4

つまり、「$N$回の繰り返し処理」を書きたいときは次のように書けば良いです。とりあえずは簡単なこの書き方を覚えるところから始めましょう。

for i in range(N):
    処理

for文を使うときのコツ

「$N$回の繰り返し処理」のfor文を使うときは、「列の先頭から順にカウンタ変数に代入される」という細かい動作を考えないようにしましょう。
よりおおざっぱに、for文は $i$ が1ずつ増えながら$N$回処理を繰り返す機能と考えた方が、for文を使うプログラムを書きやすくなります。

breakとcontinue

while文とfor文を制御する命令として、breakとcontinueがあります。

break

breakはループを途中で抜けるための命令です。
breakを使ったプログラムの例です。

# breakがなければこのループは i == 4 まで繰り返す
for i in range(5):

    if i == 3:
        print("ぬける")
        break  # i == 3 の時点でループから抜ける

    print(i)

print("終了")

実行結果

0
1
2
ぬける
終了

if文で i == 3 が真になったとき、break の命令を実行することでforループを抜け、終了 と表示しています。

continue

continueは後の処理を飛ばして次のループへ行くための命令です。
continueを使ったプログラムの例です。

for i in range(5):

    if i == 3:
        print("とばす")
        continue  # i == 3 のとき これより後の処理を飛ばす

    print(i)

print("終了")

実行結果

0
1
2
とばす
4
終了

上のプログラムでは、if文で i == 3 が真になったとき、 continue の命令を実行することでcontinueより下の部分を飛ばし、次のループに入ります。

問題

以下のリンク先に問題文が載っています。
EX11.電卓をつくろう2

次のように print("{}".format(変数)) と書くことで、 {} の部分に変数の中身が埋め込まれます。

a = 1
b = "Hello"

print("{}:{}".format(a, b))  # 1つ目の{}にa 2つ目の{}にb

実行結果

1:Hello

以下が問題のサンプルプログラムです。

サンプルプログラム

n = int(input())
a = int(input())

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.12.文字列（と文字）

キーポイント

• Pythonでは文字列も文字もstr型で扱う
• len(文字列変数) で文字列の長さを取得できる
• 文字列変数[i] で $i$ 文字目にアクセスできる
• 文字列変数[i] の i を添字という
• 添字は0から始まる
• 添字の値が正しい範囲内に無いとエラーになる

文字列（str型）

abc や hello のように、文字が順番に並んでいるもののことを文字列といいます。
C++ では文字列と文字（長さが1）を区別しますが、Python では区別せず、両方とも文字列（str型）として扱います。

str1 = input()
str2 = ", world!"

print(str1 + str2)

入力

Hello

実行結果

Hello, world!

文字列の長さ

文字列の長さ（文字数）は len(文字列変数) で取得できます。

s = "Hello"
print(len(s))

実行結果

5

i 番目の文字

次のように書くと $i$ 文字目が取得できます。

文字列[i]

この i のことを添字と言います。

添字は0から始まる

添字は0から始まることに注意しましょう。

s = "hello"
print(s[0])  # h
print(s[4])  # o

実行結果

h
o

s[0] で1文字目、s[4] で5文字目を取得しています。
"hello" という文字列の場合、添字と文字の対応は次の表の通りです。

添字	0	1	2	3	4
文字	h	e	l	l	o

ループのカウンタ変数を0から始めるのと同じように、添字が0から始まることにも慣れていきましょう。

応用

ループ構文との組み合わせ

文字列はループ構文と組み合わせることで様々な処理が記述できるようになります。
次のプログラムでは、入力された文字に何文字 O が含まれているかを数えています。

s = input()

count = 0
for i in range(len(s)):
    if s[i] == "O":
        count += 1

print(count)

入力

LOOOOL

実行結果

4

また Python では次のように書くこともできます。for文は列の先頭から順に見ていくため文字列にも対応しており、文字列の場合は先頭の文字から1文字ずつ順番に見ていきます。

s = input()

count = 0
for i in s:
    if i == "O":
        count += 1

print(count)

入力

LOOOOL

実行結果

4

注意点

範囲外エラー

添字の値が正しい範囲内に無いと実行時エラーになります。
次のプログラムは hello という5文字の文字列（有効な添字は 0 〜 4）に対して、 [10] で存在しない文字数目にアクセスしようとしているため、エラーが発生します。

x = "hello"
print(x[10])

実行時エラー

Traceback (most recent call last):
  File "./Main.py", line 2, in <module>
    print(x[10])
IndexError: string index out of range

終了コード

256

添字が範囲外のときのエラーでは、4行目で "string index out of range"(範囲外) というエラーメッセージが表示されることが特徴です。

全角文字の扱い

Python では C++ と違って全角文字が扱えます。

s = "こんにちは"
print(s[0])
print(s[2])

実行結果

こ
に

問題

以下のリンク先に問題文が載っています。
EX12.足したり引いたり

サンプルプログラム

s = input()

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.13.リスト（配列）

キーポイント

• Python では配列ではなくリストを使う
• リストは様々なデータの列を扱うことができる機能
• リスト変数名 = [要素1, 要素2, ...] でリストを作成できる
• リスト変数[i] で $i$ 番目の要素にアクセスできる
• len(リスト変数) でリストの要素数を取得できる
• リストとfor文を組み合わせると、大量のデータを扱うプログラムを簡潔に書ける
• リストの添字のルールは文字列と同じ

リストと文字列

文字列は「文字の列」を扱うための機能でした。
リストは文字だけでなく、様々なデータの列を扱うことのできる非常に重要な機能です。

C++ では配列（vector）を扱いますが、Python ではリスト（list）を扱います。
主な違いは次の通りです。

	違い
C++ の vector	1つの配列に入れられるのは1つの型のみ
Python の list	異なる型のデータを1つのリストに入れられる

文字列とリストは使い方もある程度同じです。
次のプログラムは、「"a", "b", "c", "d"」という文字の列と、「25, 100, 64」という整数の列を扱っています。

# 文字列
s = "abcd"  # "a", "b", "c", "d" という文字の列を入力

print(s[0])  # 1つ目である "a" を出力

print(len(s))  # 文字列の長さである 4 を出力


# リスト
a = [25, 100, 64]  # 25, 100, 64 という整数（int）の列を代入

print(a[0])  # 1つ目である 25 を出力

print(len(a))  # リストの長さである 3 を出力

実行結果

a
4
25
3

リスト変数の生成

リスト変数は次のように生成します。

リスト変数名 = [要素1, 要素2, ...]

リストが持つデータの1つ1つのことを要素と呼びます。
a = [25, 100, 64] と書いた場合、「25, 100, 64」というデータ列がリスト変数 a に代入されています。

i 番目の要素

文字列と同様に、リストも [i] を使って $i$ 番目の要素へアクセスできます。

リスト変数[i]

リストでも添字は0から始まります。
a = [25, 100, 64] というリスト変数 a の場合、添字の値と文字の対応表は次の通りです。

添字	0	1	2
要素	25	100	64

リストの要素数

文字列と同様に、リストも len() を使って要素数（長さ）を取得できます。

len(リスト変数)

a = [25, 100, 64] というリスト変数 a の場合、len(a) の値は 3 になります。

リストへの入力

空白区切りの入力

空白区切りの入力の受け取りで input().split() を扱いましたが、実はこれはリストとして受け取っています。

a = input().split()
print(a)

入力

3 1 4 1 5

実行結果

['3', '1', '4', '1', '5']

これだけだとｓｔｒ型として受け取ってしまうので、int型で受け取るには map() を使います。 map() を使うことで、リストの全ての要素に対して型の変換を行うことができます。

a = list(map(int, input().split()))
print(a)

入力

3 1 4 1 5

実行結果

[3, 1, 4, 1, 5]

map() だけだとmapオブジェクトになってしまうため、list() でくくることでリストに直しています。

改行区切りの入力

次のような改行区切りの入力を受け取りたいときもあります。

3
1
4
1
5

その場合は、まず空のリストを作ってから順番に要素を追加していきます。
空のリストは要素を何も書かないことで作ることができます。

リスト変数 = []  # 空のリスト

リストに要素を追加するには、.append(追加する要素) を使います。

リスト変数.append(追加する要素)

これらとfor文を組み合わせることで、改行区切りの入力を受け取ることができます。

n = int(input())  # 入力の1行目が要素数の場合

a = []
for i in range(n):
    a.append(int(input()))

print(a)

入力（1行目は要素数）

5
3
1
4
1
5

実行結果

[3, 1, 4, 1, 5]

リストの使い所

リストとfor文を組み合わせると、大量のデータを扱うプログラムを書くことができます。
次の例題を見て下さい。

例題

問題文は本家を参照してください。

解答例

$N$ が小さい場合、リストを使わずにint型の変数だけでこの問題を解くことも可能です。
しかし、$N$ が大きい場合はリストを使わずに書くのは非常に大変になります。
例えば $N = 1000$ だったとき、変数を1000個宣言しなければなりません。

リストとfor文を使えば、$N$ の大きさに関わらず簡潔に処理を書くことができます。

n = int(input())

# 数学と英語の点数データを受け取る
math = list(map(int, input().split()))
english = list(map(int, input().split()))

# 合計点を出力
for i in range(n):
    print(math[i] + english[i])

注意点

文字列と同様に、リストにも添字の値が正しい範囲内に無いとエラーになります。

次のプログラムは [1, 2, 3] という3要素のリスト（有効な添字は 0 〜 2）に対し、[10] で存在しない要素にアクセスしようとしているため、エラーが発生します。

a = [1, 2, 3]
print(a[10])

実行時エラー

Traceback (most recent call last):
  File "./Main.py", line 2, in <module>
    print(a[10])
IndexError: list index out of range

終了コード

256

文字列と同様に、4行目で "IndexError: list index out of range"(範囲外) というエラーメッセージが表示されます。

細かい話

細かい話なので、飛ばして問題を解いても良いです。

後ろからの添字

Python では、添字にマイナスを使うことで後ろから見ることができます。

a = [1, 2, 3, 4, 5]

print(a[-1])  # 後ろから1番目
print(a[-3])  # 後ろから3番目

実行結果

5
3

後ろから見る場合は、一番後ろを -1 として、後ろから2番目が -2 、3番目が -3 と数えます。

スライス

Python のリストでは、スライスと呼ばれるリストの一部分を取得する操作があります。
スライスは次のようにして使います。

リスト変数[始点の添字:終点の添字]

始点の添字から始め、終点の添字の1つ手前までがリストとして取得されます。
a = [1, 2, 3, 4, 5] というリスト変数 a の場合、 a[1:3] は [2, 3] になります。添字を省略すると、始点の場合は先頭から、終点の場合は一番後ろまでを取得します。

また、スライスはステップ（いくつおきに見るか）を指定することもできます。

リスト変数[始点の添字:終点の添字:ステップ]

例えばステップに 2 を指定すると、要素を1つ飛ばしで取得することができます。

a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(a[::2])  # 先頭から1つ飛ばし → 偶数番目
print(a[1::2])  # 奇数番目

実行結果

[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]

問題

以下のリンク先に問題文が載っています。
EX13.平均点との差

サンプルプログラム

n = int(input())

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.14.標準ライブラリの組み込み関数(STLの関数)

キーポイント

• 関数を使うとプログラムのまとまった機能を簡単に使うことができる
• Python で用意されている関数等がまとまっているもののことを標準ライブラリという
• 標準ライブラリ内に用意されている関数のことを組み込み関数という
• 関数名(引数1, 引数2, ...) で関数を呼び出せる
• 関数に ( ) で渡す値のことを引数という
• 関数の計算結果のことを返り値または戻り値という
• 引数と返り値は型のルールが決まっており、間違えるとエラーになる

関数	min(a, b)	max(a, b)
機能	aとbの小さい方の値を返す(3つ以上も可能)	aとbの大きい方の値を返す(3つ以上も可能)

関数	sorted(list)	reversed(list)
機能	リストをソートする（要素を小さい順に並び替える）	リストの要素の並びを逆にする

組み込み関数

関数を使うとプログラムのまとまった機能を簡単に使うことができます。

関数の使い方

「2つの変数の値のうち小さい方を出力するプログラム」を例として見てみましょう。

関数を使わないで書く場合、次のようになります。

a = 10
b = 5

if a < b:
    answer = a
else:
    answer = b

print(answer)

実行結果

5

「min関数」を使えば次のように書くことができます。

a = 10
b = 5

answer = min(a, b)  # min関数

print(answer)

実行結果

5

プログラム中に出てくる min は2つの値のうち小さい方を求める関数です。
min(a, b) の「計算結果」として a と b の小さい方の値が取得できるので、それを変数 answer に代入しています。

標準ライブラリとは

Python には min の他にも様々な関数が用意されており、多くの機能を自分でプログラムを書くこと無く利用できます。
Python で用意されている、関数等がまとまっているもののことを標準ライブラリ(Standard Library)といいます。また、標準ライブラリ内に用意されている関数のことを組み込み関数といいます。

関数を自分で作ることもできます。それについては「1.15.関数」で説明します。

関数の呼び出し方

関数を使うことを関数呼び出しといいます。

関数呼び出しの記法は以下の通りです。

関数名(引数1, 引数2, ...)

引数（ひきすう）とは、関数に渡す値のことです。 min(a, b) では変数aと変数bがそれに当たります。
min関数では2つの引数がありましたが、引数の数は関数によって異なります。

関数の計算結果の値のことを返り値（かえりち）または戻り値（もどりち）といいます。
answer = min(a, b) では、min関数の返り値を変数answerに代入しています。

引数と返り値の型

引数と返り値は関数によって型のルールが決まっており、間違うとエラーになります。

次のプログラムは、min関数の引数にint型とstring型を渡そうとして、エラーが発生しています。

s = "hello"

a = min(10, s)

print(a)

エラー

Traceback (most recent call last):
  File "./Main.py", line 3, in <module>
    a = min(10, s)
TypeError: unorderable types: str() < int()

関数の例

組み込み関数の中から2つの関数を紹介します。
これらを暗記しておく必要はありませんが、「この処理は組み込み関数でできた気がする」と思い出して調べられることが大切です。

min関数

min関数は、引数のうち一番小さい値を返します。3つ以上の引数にも対応しています。

answer = min(10, 5)

print(answer)  # 5

実行結果

5

引数と返り値の型

引数と返り値の型は、int や float のような数値型（または大小比較できる型）ならなんでも良いです。リストを引数に取ることもできます。

answer = min(1.5, 3.1)

print(answer)  # 1.5

実行結果

1.5

int型とfloat型の比較もできます。

a = 1.5
print("a:", type(a))

b = 10
print("b:", type(b))

answer = min(a, b)

print(answer)  # 1.5

実行結果

a: <class 'float'>
b: <class 'int'>
1.5

max関数

max関数は、引数のうち一番大きい値を返します。3つ以上の引数にも対応しています。

answer = max(10, 5)

print(answer)  # 10

実行結果

10

引数と返り値の型

引数と返り値の型についてはminと同様です。

リストを引数にする関数

組み込み関数の中から、リストを引数に渡す2つの関数を紹介します。

reversed関数

reversed関数を使うと、リストの要素の並びを逆にできます。

a = [1, 5, 3]

a = list(reversed(a))  # [3, 5, 1]

print(a)

実行結果

[3, 5, 1]

イテレータが返ってくるため、list() を使ってリストに変換しています。

また、スライスを使うことでも逆順のリストを取得することができます。

a = [1, 5, 3]

a = a[::-1]

print(a)

実行結果

[3, 5, 1]

sorted関数

データ列を順番に並び替えることをソートといいます。
sorted関数を使うと、リストの要素を小さい順に並び替えることができます。

a = [2, 5, 2, 1]

a = sorted(a)  # [1, 2, 2, 5]

print(a)

実行結果

[1, 2, 2, 5]

また、sorted関数は第2引数に reverse=True を指定すると、大きい順にソートできます。

a = [2, 5, 2, 1]

a = sorted(a, reverse=True)  # [5, 2, 2, 1]

print(a)

実行結果

[5, 2, 2, 1]

sum関数

sum関数は引数のリストの全要素の合計値を返します。

a = [2, 5, 2, 1]

print(sum(a))

実行結果

10

問題

以下のリンク先に問題文が載っています。
EX14.三人兄弟の身長差

サンプルプログラム

a, b, c = map(int, input().split())

# ここにプログラムを追記

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

1.15.関数

キーポイント

• 関数を作成することを関数を定義するという

def 関数名(引数1の名前, 引数2の名前, ...):
    処理

• 関数の返り値はreturn文を使って return 返り値 で指定する
• 関数の返り値は書かないことも可能
• 関数の引数が不要な場合は定義と呼び出しで () だけを書く
• 処理がreturn文の行に達した時点で関数の処理は終了する
• 引数に渡された値は基本的にコピーされる

関数

関数を作成することを関数を定義するといいます。

次の例では、組み込み関数のmin関数に近い機能を持つ関数 my_min を定義しています。

# 関数定義
def my_min(x, y):
    if x < y:
        return x
    else:
        return y


answer = my_min(10, 5)
print(answer)

実行結果

5

関数の動作

本家にプログラム全体の動作を説明したスライドがあります。

関数の定義

関数の定義は、関数呼び出しを行う行よりも前で行います。

関数定義の記法は次の通りです。

def 関数名(引数1の名前, 引数2の名前, ...):
    処理

前の節で見た通り、引数は「関数に渡す値」、返り値は「関数の結果の値」のことです。

my_min関数は引数を2つ受け取るので、定義は次のようになります。

def my_min(x, y):

呼び出し方は組み込み関数と同様です。
次のように呼び出した場合、引数 x に 10 が代入され、引数 y に 5 が代入されます。

my_min(10, 5)

返り値の指定

関数の返り値は、return文で指定します。

return 返り値

my_min関数では2つの引数 x, y のうち小さい方を返すので、次のように書きます。

if x < y:
    return x
else:
    return y

返り値がない関数

関数の返り値が無いこともあります。その場合は、return文を書く必要はありません。

def hello(text):
    print("Hello, " + text)


hello("Tom")
hello("Python")

実行結果

Hello, Tom
Hello, Python

引数が無い関数

関数の引数が不要の場合は、定義と呼び出しでは () だけを書きます。

def int_input():
    x = int(input())
    return x


num = int_input()
print(num, type(num))

入力

10

実行結果

10 <class 'int'>

関数を自分で定義する理由

本家を参照してください。

注意点

return文の動作

処理がreturn文に到達した時点で関数の処理は終了します。

一つの関数の中にreturn文が複数あっても問題ありませんが、return文より後に書いた処理は実行されないことに注意しましょう。

次のプログラムでは、 "Hello, " を出力した次の行で return と書いているため、その後の処理は実行されません。

def hello():
    print("Hello, ", end="")
    return  # この行までしか実行されない

    print("world!")
    return


hello()

実行結果

Hello, 

引数はコピーされる

他の変数に値を代入したとき同様に、基本的に引数に渡した値はコピーされます。

次のプログラムのadd5関数は関数内で引数に 5 を足していますが、呼び出し元の変数numの値は変化しません。

def add5(x):
    x += 5
    print(x)


num = 10
add5(num)

print(num)

実行結果

15
10

関数が呼び出せる範囲

関数は宣言した行より後でしか呼び出せません。

次のプログラムでは、hello関数を定義した行より前でhello関数を呼び出しているため、エラーが発生しています。

hello()


def hello():
    print("hello!")

エラー

Traceback (most recent call last):
  File "./Main.py", line 1, in <module>
    hello()
NameError: name 'hello' is not defined

上から順に読み込んで実行されるため、1行目の時点では「まだhello関数が定義されていません」とエラーが出ています。

問題

以下のリンク先に問題文が載っています。
EX15.三人兄弟へのプレゼント

A君が書いたプログラム

# 1人のテストの点数を表すリストから合計点を計算して返す関数
# 引数 scores: scores[i]にi番目のテストの点数が入っている
# 返り値: 1人のテストの合計点
def sum_scores(scores):
    # ここにプログラムを追記


# 3人の合計点からプレゼントの予算を計算して出力する関数
# 引数 sum_a: A君のテストの合計点
# 引数 sum_b: B君のテストの合計点
# 引数 sum_c: C君のテストの合計点
# 返り値: なし
def output(sum_a, sum_b, sum_c):
    # ここにプログラムを追記


# ---------------------
# ここから先は変更しない
# ---------------------

# 1行の整数が空白区切りになった入力を受け取ってリストに入れて返す関数
# 引数 s: 1行の、整数が空白区切りになった入力
# 返り値: 受け取った入力のリスト
def list_int_input(s):
    a = list(map(int, s))
    return a


# 科目数Nを受け取る
n = int(input())

# それぞれのテストの点数を受け取る
a = list_int_input(input())
b = list_int_input(input())
c = list_int_input(input())

# プレゼントの予算を出力
output(sum_scores(a), sum_scores(b), sum_scores(c))

解答例

必ず自分で問題に挑戦してみてから見てください。
解答例

おわりに

以上で第1章は修了です。
本記事では APG4b の第1章のみを扱いました。気が向いたら第2章以降も書こうと思います。

はじめに書いたように、問題があれば本記事は削除します。