はじめに（☆に関して）

プログラミングの全くの未経験者の方は、__☆__のついた部分だけ最低限読み進めてみてください。

Python環境構築

環境構築ができていない方は、ブラウザでPythonの環境構築なしに、PythonプログラミングができるWebサービスをご利用ください。

Google Colaboratory
（詳細は下記記事をご参考ください。）
https://qiita.com/AI_Academy/items/0623620c8f83f593f696

try Jupyter
または、パイザをご利用ください。
(※無料Webサービスを使うか、手元のPCに環境を構築するなどお好きなもので構いません）

・手元のPCにPythonを動作させたい場合は下記記事をご確認ください。
http://qiita.com/AI_Academy/private/257e289b60f28393f194

プログラミング言語 Pythonとは ☆

プログラミング言語 Pythonとは、1991年にオランダ人のグイド・ヴァン・ロッサム氏によって開発された汎用的なプログラミング言語です。

GoogleやDropBoxなど世界的に使われている言語です。
この章では、Pythonの基本文法を簡単に見ていきます。

Pythonで出来ること ☆

ざっと大きくあげると以下になります。

1 人工知能関連（画像認識・自然言語処理・音声認識 etc..)
2 機械学習・統計解析
3 Webアプリケーション・Webサービス開発
4 デスクトップアプリ制作(tkinterなど)
5 業務効率化プログラム
6 スクレイピング
7 IoT
8 ロボット制御
9 ネットワーク・サイバーセキュリティプログラミング
10 ゲーム開発
11 Blender(オープンソースで提供されている3DCG高機能モデリングソフト)やMayaなどを使った、3次元コンピュータグラフィックスの処理

スマートフォンアプリなどは、Pythonは向いていません。(Kivyを使うことで作成は出来ます)
本格的なiOSやAndroidアプリを作りたい場合は、Swift(iOS)やJava(Android)を学ぶ必要があります。
近年では、React NativeというFacebookが開発したモバイルアプリ向けのJavaScriptのフレームワークなどもあります。
3DやAR・VRアプリケーションの場合は、Unity(C#など)を使う必要があります。
上記の内容が気になった方は調べて見てください。

Python実行方法

Pythonを実行するには大きく2通りあります。
1つは、テキストエディタなどに書いたプログラムを、ターミナルやコマンドプロンプトから実行する方法
2つは、Pythonインタラクティブシェル（対話モード）から実行
から実行する方法です。

近年だと、__Jupyter Notebook__のようなWebからPythonを実行できるものもあります。
Jupyter NotebookをWebで使ってみたい方は下記サイトにアクセスしてみてください。
try Jupyter

また中でもオススメなのはGoogle Colaboratoryです。
GPU環境も無料でWebから使うことが可能です。
(※Googleアカウントが必要です。）

ターミナルやコマンドプロンプトから実行する方法

こちらは、記述したpythonファイル名(拡張子が.py）をpythonコマンドで実行します。

ターミナルやコマンドプロンプトを開き、例えば、sample.pyを実行する方法です。

python sample.py

※Mac ターミナルの場合

Pythonインタラクティブシェル（対話型シェル / 対話モード）

Pythonがインストールされていれば、コマンドプロンプト・ターミナルで__python__と実行すると次のような画面になります。

Pythonインタラクティブシェル（別名Pythonインタプリタ）はPythonのコードを1行1行読み込み
実行することが出来ます。

どちらの方法でも実行できますが、1の場合保存してファイルとして残しておけますが、
2の場合、インタラクティブシェル（コマンドプロンプトやターミナル）を終了すると、
これまで入力したコードは保存されないので消えてしまいます。

簡単なコードを入力し試したい場合は2で良いと思いますが、
プログラムを本格的に作る場合、1の方法で行うのが良いです。
場合によって使い分けるのが良いです。

Pythonの特徴 - インデント ☆

Pythonの特徴として、インデント（字下げ）することが重要になってきます。
Pythonではインデントがコードブロックの開始と終了を伝える役割をしています。

まずは以下のコードを見てください。
これは、0〜4までの値を出力するプログラムをPythonで記述した例です。

for i in range(0,5):
    print(i) # 4つのタブでインデント（字下げ）をする

このように、Pythonでは、__インデントがブロック__の区切りとして認識しています。
そのために、次のようにコードを書くとエラーになります。

for i in range(0,5):
print(i) # Error!!

他の言語だと、__「{}」や「beginとend」__でブロックとして認識するのに対し、
Pythonではインデントがブロックとしての役割を担うので、
最初は慣れないかもしれませんが、コードを書いているうちに慣れてきますので、抑えておきましょう。

余談ですが、プログラム中は、よく__print()__や変数の代入の際にスペースを開けたりすることがあります。
結論から言うと、以下のプログラム(1)と(1)、(2)と(2)はそれぞれ同じプログラムです。

print(3+3)  # (1)
print(3 + 3)  # (1)

a = "apple" # (2)
a="apple" # (2)

()内や変数の前後にスペースをあけてる場合と、1つあけない場合もありますが、
これはどちらも同じ意味でスペースを入れなくても大丈夫です。
このテキストでは、見栄えを多少よくするために、スペースを入れて記述してあります。

コメント ☆

プログラム内に、#もしくは""" """で記述されているのは、コメントです。
コメントはプログラム内で、メモを残せ、実行に影響がありません。
ですので、上の記述を見かけたらコメントを記述しているということになります。

# は、1行コメント、""" """は複数行コメントができます。
(シングルクォート3つづつで囲っても複数コメントができます。トリプルクォートと呼びます。)

エラーと例外に関して ☆

Pythonには、構文エラー(SyntaxError)と例外(Exception)という2種類のエラーがあります。

構文エラーは致命的なエラーであり、構文エラーがある場合プログラムは実行できません。
基本的にエラー内容は、SyntaxError: というメッセージで始まるものが構文エラーです。

そして、それ以外のエラーは全て例外エラーです。
例外は一見、文や式が構文的に正しくても、実行しようとしたときにエラーが発生するもので、IndexErrorやTypeErrorやNameErrorやZeroDivisionErrorなどがあります。
これらのエラーは構文エラーとは違って致命的ではないので、例外処理を記述していればプログラムは実行し続けることが出来ます。

一旦、エラーには2種類あるというのだけここでは知っておいてください。

四則演算 ☆

加算や乗算などの四則演算を行ってみましょう。

print(5+3)
print(5-3)
print(5*6)
print(10/5) # 3系では割り算の結果が小数点になります。整数にしたい場合は/の代わりに、//と記述することで実現できます
print(10%5)
print(10**2)

補足

__format()__を使うことで、小数点第何位まで出力するかも決めることが出来ます。

# .3fというのは、小数点第3位までを出力するという指定
print("{0:.3f}".format(10/2)) # 5.000

# .5fというのは小数点第5位までを出力するという指定
print("{0:.5f}".format(10/2)) # 5.00000

変数 ☆

__変数とは、データを入れる箱（入れ物）__だと思ってください。
名前のように様々な値をこの変数と呼ばれる箱に入れることができます。
変数に値を入れることを代入と呼びます。
Pythonは変数の型によって自動的に決定される言語です。
他の言語だと、型宣言をしますが、Pythonには型宣言がなく、以下のように様々な種類の型の値を代入できます。

x = "hello world"
y = 42

print(x)
print(y)

y = 100 # 42から100に上書き
print(y*3.14)

上記プログラムはあくまでの変数の使い方の説明でしたが、
次の変数を使わないプログラムと使ったプログラムを比べてみてください。
ここでは、変数がどれだけ便利なものなのかを知って頂きたいと思います。

まずは、変数を使わない場合のプログラムを見てみましょう。

print(15 + 1)
print(15 - 2)
print(15 * 3)
print(15 / 4)
print(15 % 5)

では15を220に書き換えてください。
もしこの場合、15と書かれた5つのprintの部分を全て220に書き換える必要が出てきます。
5行だけならまだそこまで大変ではありませんが、もし100行、1000行だとどうでしょう。。。？

さて、ここで変数の登場です。
もしも最初から変数xというものが定義されていたら、__x = 15__というのを、
__x = 220__に書き換えるだけで良いです。

x = 220
print(x + 1)
print(x - 2)
print(x * 3)
print(x / 4)
print(x % 5)

先ほどは5行分の修正が必要だったものが、1箇所変えただけで終わります。
こんなに変数は便利ですので、是非使っていきましょう。

計算式の優先順位

Q. 1と2の違いを実行して比べてみてください！

y_1 = 10
y_2 = 20
print(y_1 + y_1 * y_2)    # 1
print((y_1 + y_1 ) * y_2) # 2

データ型 ☆

Pythonに限らず、プログラミング言語には、データの性質を表す、__データ型__というものがあります。
type()という関数を利用することで、データ型を調べることができます。

print(type(12))
print(type("Python"))
print(type(14.4))

実行すると、int__や__str、__float__などが出力されます。
これが型と言われるもので、intは整数型、strは文字列型、floatは浮動小数点型という型を意味しております。
他にもPythonにはリスト型や辞書型などいくつかの型が存在します。

文字列型(str) ☆

文字列を扱うのが__str(文字列型)__です。
''や""で囲むと文字列型になります。

a = 'I like python.' 
b = 'I\'m good.'
c = "I'm good."
d = 'My freind said, "I like PHP. but I like python better."'

文字列の連結 ☆

message = "hello" + "world"
print(message)

反復 ☆

*演算子を使うことで繰り返すことが出来ます。

print(3 * "hello" + "world") # helloを3回 繰り返し、その後文字列worldと連結

message = "hello" + "world" # helloとworldを連結させた変数meessage
print(message * 5) # 変数messageを5回掛け合わせる。

型変換(キャスト) ☆

型を変換することを型変換（キャスト）と呼びます。

"""
int() str()
"""

a = int(1.0)
print(10 - a)

# print("python" + 10)
print(10 - int("5"))
print("hello" + "world")

ブーリアン（真偽値型） ☆

Pythonにはboolという型があり、ブーリアン型とも呼ばれます。
bool型には、__True__と__False__という2つの値があります。

t = True
f = False
print(type(t)) # <class 'bool'>
print(type(f)) # <class 'bool'>

t = True
f = False
# andやof、notを使い真偽値を求められます。
t or t # TureもしくはTrue => True
t and t # TrueそしてTrue => True

また、Trueは1という値も意味し、Falseは0という値の意味を持ちます。
次のようなこともできます。

print(True + 1) # 1 + 1 または、上のプログラムでは t + tと同じ
print(False + 5) # 0 + 5 または、上のプログラムでの f + 5と同じ

bytes (バイト列)

エンコード(符号化）
デコード（複合化）

a = "エーアイ"
a = a.encode('utf-8')
print(a)
# b'\xe3\x82\xa8\xe3\x83\xbc\xe3\x82\xa2\xe3\x82\xa4'
b = a.encode('utf-8')
# b'\xe3\x82\xa8\xe3\x83\xbc\xe3\x82\xa2\xe3\x82\xa4'
i = b.decode('utf-8')
print(i)

リスト ☆

他の言語だと、配列やArrayと呼ばれておりますが、Pythonではリストと呼びます。
リストとしてデータを扱うには以下のように記述します。
リストは[]を使い記述します。

li = [1,2,3,4,5]
print(li) # [1,2,3,4,5]が出力
print(len(li)) # リストの要素数（長さ）を調べたい時にはlen()を使います。

リストの要素にアクセスする方法を見ていきましょう。
リストが先頭の要素を0番目として数えます。
ですので、以下のリストから1を取り出したい時は、以下のように記述します。

# 添え字  0 1 2 3 4 ...

li =    [1,2,3,4,5]
print(li[0]) # 1が出力

# リストはミュータブルなので、以下のように
# 書き換えられる。 添え字0を100に変更
li[0] = 100

# 変更後のリスト(li)を出力
print(li)

リストの連結

li1 = [1, 2, 3]
li2 = [4, 5, 6]

li3 = li1 + li2
print(li3) # [1, 2, 3, 4, 5, 6]

maxとmin

max関数やmin関数を使うことで、特定の値や要素の中から最小値、最大値を取得することが可能です。

num = [20, 50, 15, 40, 15, 5]
alpha = ['A', 'J', 'W','T','Y', 'Z']
print(min(num))   # 5
print(max(alpha)) # Z

リストでよく使う関数

■ append() ☆
appendはリストの末尾に要素を1つ追加します。

li = [10, 52, 2, 14]
li.append(100)
print(li)

■ insert()
第一引数には要素のインデックス(添え字）を書き、
第二引数には追加したい要素を書く。

li = [10, 52, 2, 14]
li.insert(2, -1) # 2番目の添え字が2なので、2の直前に-1がinsertされる
print(li)

■ extend()
extend()は、引数にリストを渡すことで、あるリストに引数に渡したリストを追加します。

a = [10, 52, 2, 14]
b = [1,1]
b.extend(a) # リストbの要素の末尾に、リストaの全要素を追加
print(b)

■ remove()

リスト.remove(X)

remove関数の引数(ここではX)である最初の要素を削除する。
もし、引数渡したアイテムが存在しない場合エラーになります。

li = [2,1,2,5,10]
print("remove前", 2)
li.remove(li)
print("remove後", 100) # 100は存在しないので、エラーになる。

■ sort()

リスト.sort(key=None, reverse=False)

li = [24,515,1,49,85,99,1002]
li.sort()
print(li)

他にも、__remove()や__pop()、__count()__などなど、便利な関数があります。
また、pop()と値を返さないという違いで、__del文__というのもありますので、
これらをまた調べて使って見てください。

■ sorted()

sortedの関数版です。

li = [5, 2, 3, 1, 4]
print(sorted(li))

■ sort()とsorted()の違い
sort()は、リスト型のメソッドなのに対して、sortedは関数です。
http://ututel.blog121.fc2.com/blog-entry-58.html

insertやremove、sortはメソッド(クラスの中に定義された関数)であり、これらは
リストの値を変更するだけの役割で、戻り値はデフォルトでNoneになっています。
戻り値(返り値)は関数の章で説明します。

sort()とreverse()

スライス ☆

スライスは、listやstrなどの型で利用が可能で、部分的な要素を取得することが可能です。

li = [1, 2, 3, 4, 5]
print(li[0: 4]) # [1, 2, 3, 4]
print(li[: 4])  # [1, 2, 3, 4]
print(li[-3:])  # [3, 4, 5]
print(li[2: -1])# [3, 4]

# 覚えておくと良い手法

# 逆順
print(li[::-1]) # [5, 4, 3, 2, 1]
print(li[:])    #  [1, 2, 3, 4, 5]

タプル ☆

リスト型は変更可能なミュータブルと呼ばれて変更可能な値なのに対して、
タプルはイミュータブル（生成後変更不可能）なデータ型になります。
タプル(Tuple)は使い慣れるまではリストとの使い分けが難しいところはありますが、よく使われるのは
関数の戻り値（後で説明致します）として値のペアを返したいといったときなどに使います。

t = (5,10) 
print(t[0])
t[0] = 100 # エラーになる
"""
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
"""

t = 123, 555, 150, "hello"
print(t[0])

# タプルは入れ子も出来ます。
t2 = t, (1,2,3)
print(t2) # ((123, 555, 150, 'hello'), (1, 2, 3))

# 1つ値のタプルは、カンマをつける必要があります。
t3 = "hello",
print(t3)
print(type(t3))

集合型(セット)

集合型は、値（要素）をグループわけすることが可能で、集合演算（和集合、積集合など）が行えます。
記述方法は集合にしたい値を,で区切り、{}で囲います。
辞書型と書き方は似ています。

group1 = {"apple", "banana", "grape"}
group2 = {"orange", "grape", "pear"}

# 空の集合の定義
s = set()

# 標準関数のset()を使うことで、連番の集合の作成や、集合型にキャストが可能です
set1 = set(range(0,10))

辞書型 ☆

辞書型は、キーと値をペアとしてデータを管理します。
リスト型はインデックス番号が0から始まり、0から順に値が格納されていました。

profile = {'name': 'tani', 'email': "kazunori-t@cyberbra.in" }
print(profile['name']) # tani

# 新しく要素を追加
profile['gender'] = 'male'

# 新しく要素を追加した辞書型(profile)を出力
print(profile)

■ keys()

keys()を使うことで、ある辞書の全てのkeyを取り出せる

profile = {'name': 'tani', 'email': "kazunori-t@cyberbra.in" }
print(profile.keys())

print(list(profile.keys()))

■ values()
values()を使うことで、ある辞書の全てのvalueを取り出せる

profile = {'name': 'tani', 'email': "kazunori-t@cyberbra.in" }
print(profile.values())
print(list(profile.values()))

■ items()
items()を使うことで、ある辞書の全てのkeyとvalueを取り出せる。
ですが、リストの要素はタプルに入って返って来ます。

profile = {'name': 'tani', 'email': "kazunori-t@cyberbra.in" }
print(profile.items())
print(list(profile.items()))

他にも、ここでは扱わなかったsetdeault()やfromkeys()、clear()、pop()といったメソッドもあります。

条件分岐(if文） ☆

条件分岐を使うと、条件に応じて処理を分けることができます。

if文でよく使われる構文として、以下の演算子があります。

• 構文

if 条件:
    # 条件がTrueの時に実行

t = True
if t:
    print("Trueです")

また、elseも使いTrueじゃない時に実行されます。

t = True
f = False

if f: # FlaseはTrueかどうか
    print("Trueです")
else:
    print("Falseです")

elifを記述することで、追加で条件式を追加できます。
elifはif文の中でいくつあっても問題ありません。

score = 90

if score == 100:
    print("満点")
elif score > 85:
    print("合格！")
else:
    print("不合格。次回頑張りましょう。")

ここでみるとわかりますが、Pythonではインデントが重要な意味を持っているので、最初のif文の後に、スペースが4つインデントされています。

論理演算子

論理演算子と呼ばれる演算子は、Pythonには3種類あります。
and、or、notがあり、それぞれ、論理積、論理和、否定の演算を意味しており、
以下のようなことも可能です。

a = 10
b = 10
if a == 10 and b == 10:
    print("aとbも10です")
elif a == 10 or b == 10:
    print("aもしくはbが10です")
else:
    print(a,b)

a = 12
if 1 < a and a < 15:
    print("1〜15")
else:
    print("15以上")

# Pythonでは、範囲条件を1 < a < 15と書くことが出来ます。

制御構文（for文） ☆

ループ処理を行うには、for文を使います。

for文ではrange()をよく使います。
forの右にあるのはループ内変数と呼ばれる変数で、このループの中だけで有効な変数です。

for i in range(0,5): # 0から4までの5回を繰り返す
    print(i)

■ range()関数

先ほどのように、for文では__range()__をよく一緒に使います。
range()は0以外の数字から、またそれ以外の数字からも始めることが出来ます。
range(5)とすると0〜4までの計5個の値が生成されます。

range(5) # 0〜4まで

range(0,6) # 0〜5まで

range(5,10) # 5〜9まで

range(0, 5, 2) # 0,2,4

# range(-5, -30, -2) は、-5〜-29まで-2づつ増分
for i in range(-5, -30, -2):
	print(i)

"""
-5
-7
-9
-11
-13
-15
-17
-19
-21
-23
-25
-27
-29
"""

また__range()__と合わせて使う以外にも、リストを使う方法もあります。

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

"""
5
4
3
2
1
"""

辞書型とforを組み合わせたサンプル

profile = {"name":"Tom", "email": "tom@gmail.com"}

for i in profile.keys():
    print(i)

__list()__と__range()__を一緒に使うことで、リストを生成できます。

print(list(range(-5, -30, -2)))
# [-5, -7, -9, -11, -13, -15, -17, -19, -21, -23, -25, -27, -29]

break文とcontinue文

break文は、処理をそこで中断することができます。
continue文は、処理を一度スキップすることができます。

# cotinue 1回スキップ
for i in range(10):
    if i == 3:
        continue
    print(i)

# break 処理を終了
for i in range(10):
    if i == 3:
        break
    print(i) # 0 1 2を出力

"""
先ほど見たelseをfor文と使う際に、「break」を使うと、elseの中の処理は実行されないので注意です。
この場合ですと、リスト内に"f"があるので、foundが出力されますが、
else内のnot foundは出力されません。
"""

f = [1, 2, 3, 4, 5, "f"]
for x in f:
    if x == 'f':
        print('found')
        break
else:
    print('not found') # このサンプルの場合elseの処理は実行されない！

while文

Pythonにはfor以外にも、__while文__を使うことで、繰り返し処理が出来ます。

次のプログラムは、10回繰り返し処理を行うプログラムです。

a = 0
while a < 10: # 1回目はaは0なので、0<10が成り立つ
    print(a)
    a = a+1  # 最後にaの値を1増やすこと！この行がないと次に紹介する無限ループに陥ります。

また、以下のようにすると、無限ループになります。

while True:
    print("無限ループ")

control + Cで強制終了もしくは、ターミナル・コマンドプロンプトを終了すると、プログラムは停まります。

繰り返し処理演習

次のwhile文のプログラムを、for文に書き換えてください。

a = 1
while a < 5:
    print(a)
    a = a+1 # a += 1のように書くことが多いです。（省略版）

次の無限ループのプログラムで変数iを0で定義し条件で、iが5になったら、処理を中断するプログラムを作ってください。

while True:
    print("無限ループ")

関数 ☆

ある処理をまとめたものを関数として定義できます。
関数を定義（作成）するには、__def__というキーワードを使います。
関数名は自由につけることが可能です。

def 関数名():
    # 処理

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

# 関数呼び出し
hello() # 関数名()で呼び出せる

引数とデフォルト値

# 関数の定義
def say_hello(name="ななしさん"):
    print("こんにちは、",name)

# 以下、関数呼び出し　
say_hello("谷")
say_hello("田中")
say_hello("山田")
say_hello()

返り値(戻り値)

return文を実行すると、関数を終了し呼び出し元に戻ります。

return 【返り値】

def adder(a, b):
    return a+b

print(adder(5,10)) # 15が出力される

def power(x):
    return x*x

def absolute(x):
    if (x < 0):
        return -x
    else:
        return x

print(power(10)) # 100
print(absolute(-10)) # 10

変数のスコープ

ここでは、__global__に関して学びます。

関数内でグローバル変数にアクセスするための宣言です。
ローカル変数（関数定義の内部で定義した関数）とグローバル変数（関数定義の外側で定義した変数）があります。

glb = 0 # 関数の外側で定義した変数はグローバル変数として定義される。

def func1():
    glb = 1 # このglbという変数はfunc1という関数の内部にあるので、ローカル変数

def func2():
    # func2のglbと最初の行のglbは別物。
    global glb # func2の中で定義されたローカル変数glbをグローバル変数として定義
    glb = 5

print(glb) # 0が出力される （最初の行で定義したグローバルglbを出力）
func1() # ただ関数を呼び出しただけで、グローバル変数glbの値は変更されていない。なぜなら1行目のglbとfunc1関数内のローカル変数glbは名前は同じだが、全くの別物。
print(glb) # 0が出力される
func2() # ここで初めて、最初の行で定義したglbに影響が与えられる。
print(glb) # 5が出力される(func2関数によってグローバル変数glbが更新)

では、もう一度上のプログラムを参考に次のプログラムの出力結果を考えてみましょう。

var1 = 'グローバル変数'

def sample():
    var2 = 'ローカル変数'
    return (var1, var2)

print(sample())

上記の例は、グローバル変数とローカル変数をそれぞれ宣言しています。
次のサンプルは、関数内からグローバル変数を変更するプログラムです。

var1 = 'グローバル'

def sample():
    global var1

    var1 = 'ローカル'
    var2 = 'ローカル'
    return (var1, var2)

print(sample())
print(var1)

無名関数(lambda)

無名関数とは、名前の通り、名前のない関数のこと。
匿名関数とも読んだりしますが、ここでは無名関数の作り方をみていきます。

無名関数を作るには、lambdaを使います。
lambdaはラムダと呼びます。

ラムダの構文

変数 = lambda 引数1, 引数2  : 式

・iを2倍にする無名関数

sample = lambda i : i * 2
print(sample(10)) # 20
print(sample(100)) # 200

上記のsampleというのは変数です。i*2の結果が、変数sampleに代入されています。
ちなみに、上記の無名関数を通常通り書くと以下のようになります。

def sample(i):
    return i*2

print(sample(10))

lambdaを使うことで、関数を非常にシンプルに書くことができるようになります。

map関数、zip関数、enumerate関数

■ map関数
map()関数は、リストの要素に演算を適用してくれる関数です。
map(引数1, 引数2)では、引数1に関数を渡し、引数2にはリストを渡します。

items = [1, 2, 3]
def add(n):
   return n+2

print(list(map(add, items))) # [3, 4, 5]
print(items) # [1, 2, 3]が出力。元のitemsは変更されない

# lamdaを使ったサンプル
print(list(map(lambda n:n+2, items))) # [3, 4, 5]
print([x+3 for x in items]) # リスト内包表記 [4, 5, 6]

注意として、map関数の手前にlist()で囲っているのは、python3系からmap()関数の内部の仕様がわかり、2系だとそのままリストが生成されましたが、3系からlist()を使わないとリストの形になりませんので注意です。

■ zip関数

list1 = [1, 2, 3]
list2 = [4, 5, 6]
for (a, b) in zip(list1, list2):
   print(a,b)

list3 = [7, 8]
for (a, b) in zip(list1, list3): # 要素数が少ないlist3に合わせられる
    print(a,b)

■ enumerate関数
ループする際にインデックスと合わせて要素を取得することが出来ます。

list1 = ['a', 'b', 'c']
for (i, j) in enumerate(list1):
    print(i,j)

例外処理

例外処理とは、プログラムがある処理を実行している途中で、なんらかの異常が発生した場合に、
現在の処理を中断し、別の処理を行うことです。

例外処理を記述することで、予期せぬエラーに対応できるプログラムを書くことができます。

エラーは大きく分けて2種類あります。

1. 構文エラー(Syntax Error)
2. 例外(Exception)

1. 構文エラー(Syntax Error)

>>> if 10 > 5
  File "<stdin>", line 1
    if 10 > 5
            ^
SyntaxError: invalid syntax

上記のように、構文エラー: 無効な構文
と言ったエラーが表示されており、if文の:がないためにエラーが起きています。
ファイル名及び、行数などを知らせてくれるためにエラーがどこかは発見しやすいです。

2. 例外(Exception)

プログラム的に文法や構文が正しい場合でも、実行するとエラーが起きることがあります。
Pythonでは、0徐算(0で割ること）をすると例外が発生されます

i = input()
input_num = int(i) 

result = 5 / input_num
print(result)

このようなプログラムの場合、__例外処理__を行います。

主な例外として、__ZeroDivisionError、NameError、TypeError__などがあります。

Pythonで例外処理を記述する構文は次のようになります。

try:
    例外が発生しそうな処理
except:
  print('例外発生!!')

このように例外処理を記述かのです。

try:
  5/0
except:
  print('ZeroDivisionError!!')

"""
次のようにすることも可能
try:
  5/0
except ZeroDivisionError:
  print('ZeroDivisionError!!')
"""

ファイル操作(テキストファイルの読み書き)

ここではテキストファイルにおけるファイル処理に関して見ていきます。

ファイル処理の流れは以下になります。

1） ファイルを開く => open()
2） ファイルを読み書きする => read() / write()
3） ファイルを閉じる => close()

1） ファイルを開く => open()

open(ファイル名, オープンするモード)

ファイルパス: 相対パス及び絶対パス
オープンするモード（デフォルトは"r")
r: 読み込みモード
w: 新規書き込みモード
a: 追加書き込みモード

f = open("sample.txt", "r")

2） ファイルを読み書きする => read() / write()

f = open("sample.txt", "r")
print(f.read())

f = open("sample.txt", 'w')
f.write("書き込む")
f.write("\n")

__read()__はファイルの中身を全て読み込みますが、__readline()__を使うと、ファイルから1行読み込みます。readline()を使うと末尾に改行文字(\n)が含まれます。

次のような書き方も出来ます。

f = open("sample.txt", 'r')
for line in f:
    print(line, end="")

3） ファイルを閉じる => close()

最後に、__close()__を使いファイルをクローズします。
これは開いていたファイルが治めていたシステムリソースを全て解放する処理です。

f = open("sample.txt", "r")
print(f.read())
f.close()

また、__close()__を使わない方法として、__with__を使うことも出来ます。
__with__を使った書き方の方が、良い書き方で確実にファイルを閉じてくれるという利点があります。

with open("sample.txt", "r") as f:
    data = f.read()
    print(data)

モジュール（標準モジュール） ☆

importすることでモジュールが使えるようになります。
Pythonのライブラリは__モジュール__と呼ばれており、複数の関数などが含まれています。

例えばPythonにはmathモジュールという初めから数学関連の処理をまとめた
モジュールがあります。mathモジュールのcos関数を利用することで、
cosの処理が出来るようになります。

モジュール.関数で各モジュールの関数などを使うことができます。

import math
math.cos(1) # 0.5403023058681398

fromを使うことで読み込みたいもの（関数など）だけを読み込むことが出来ます。

from モジュール名 import 関数名, 関数名, ...

>>> from math import cos
>>> cos(1)
0.5403023058681398
>>> sin(1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sin' is not defined
>>> from math import cos,sin
>>> sin(1)
0.8414709848078965

また__as__を使うことで関数名に別名を付けることができます。

from math import cos as c
print(c(1))
# 0.5403023058681398

OSモジュール

OSモジュールを使うことで、Unixシステム等で利用するコマンドをPythonの関数で実行出来たりします。

import os

# 現在のディレクトリを出力
print(os.getcwd())

# sampleディレクトリを作成する。
os.mkdir("./sample")      

■ ファイルが存在するかチェック
ファイルが存在するかチェックをするには、__exists()関数__を使います。

import os
os.path.exists("./sample.txt")  # プログラム実行ディレクトリにsample.txtがあるか。あればTrueなければFalseが返ってくる。

■ 現在のディレクトリを出力する

import os
# 現在のディレクトリを出力
print(os.getcwd())

■ カレントディレクトリを変更する

__chdir()__では、引数に、移動したいディレクトリを記述すると、
そのディレクトリに移動することが出来ます。

import os
os.getcwd() # '/Users/kazu/Desktop'
os.chdir('./sample01')
# os.getcwd() # /Users/kazu/Desktop/sample01

■ システム側のUnixコマンドをPythonから実行する

__system()__関数を使うことで、引数に、Unixのコマンドを渡せばそのコマンドをPythonで実行できます。

import os
os.system('ls')

■ ファイル名を変更する
また、ファイル名を変更したい場合は、__rename()関数__を使うことで出来ます。

import os
os.rename("sample.txt", "sample_rename.txt")

■ ファイルを削除する

次に、__remove()関数__を使うことで、ファイルの削除が可能です。

import os
os.remove("./sample.txt")     # sample.txtを削除
os.path.exist("./sample.txt") # sample.txtがあるか調べる。うまく削除出来ていれば、Falseが返ってくる。

■ ディクレトリを作成する

__mkdir()関数__を使うことで、ディレクトリを作成することができます。

import os
os.mkdir("./sample")      # sampleディレクトリを作成する。
os.path.exist("./sample") # sampleディレクトリがあればTrueが返ってくる

sysモジュール

コマンドラインツールを作るときなど、コマンドラインの引数を渡すことが良くあります。
次のようなサンプルプログラムとその実行例をみてみます。

import sys
print(sys.argv) # よくargv[1:]としますが、これは最初のファイル名を取り除いてます。

python sample.py python ruby java

['sample.py', 'python', 'ruby', 'java']が出力されます。

今回紹介しておりませんが、他にも__reモジュール(正規表現)__や、
datetimeモジュール、__urllibモジュール__などのモジュールも良く利用しますので、是非調べてみてください。

sys.path.append(os.pardir)

sysモジュールとosモジュールを組み合わせることで、
親ディレクトリに置かれているスクリプトファイルをimportすることが可能です。

import sys,os
sys.path.append(os.pardir)

オブジェクト指向プログラミング

Pythonはオブジェクト指向プログラミング言語ですが、オブジェクト指向プログラミングとはなんでしょうか？
その前に、プログラミングパラダイムに関して説明します。
プログラミングパラダイムとは、プログラミングの手法のことで、いくつか種類があります。
プログラミングパラダイムの種類には、

1. 手続き型プログラミング
2. 関数型プログラミング
3. オブジェクト指向プログラミング

が有名です。
ここでは、オブジェクト指向プログラミングに関して簡単にだけ説明します。
オブジェクト指向とは、オブジェクトに状態を持たせ、複数のクラスで相互に作用するオブジェクトの集まりを定義します。

また今回は詳しく説明しませんが、オブジェクト指向の概念を理解するには、
カプセル化や抽象化、ポリモーフィズム、継承といった4つの主要な概念の理解が欠かせません。

色々な用語が飛びかったので、まずはクラスとオブジェクトから説明していきます。
先ほど説明した内容では、今のところは用語だけ知っていれば問題ありません。

クラスとオブジェクト

クラスはよくオブジェクトの仕様書や設計図と説明されますが、クラスはデータ型を作るための仕組みで、どういったオブジェクトを作るのかの処理をまとめ、記述します。

実は、数値型や文字列型、リスト型などデータ型であり、オブジェクトは、全てクラスから作られるということです。

クラスを学び始めると、よく「オブジェクト指向（プログラミング）」といった説明もあわせて行われますが、
今回はオブジェクト指向プログラミングは大規模システムにおける開発の効率化や保守性などの向上につながるようなものというくらいに留めておき、Pythonにおけるクラスの定義や継承など基本的な構文のみ説明致します。
ですので、アクセス制御やポリモーフィズムなどの説明はここでは割愛致します。
気になった方は、調べてみてください。

クラスの作り方

# 空のクラス
"""
class クラス名
    pass # 何もしない（関数でも利用可能）
"""

# ヒーロークラス
class Hero:
    pass

インスタンスを作る

インスタンス化することで、オブジェクトを作ることが可能です。

class Hero:
    pass

h1 = Hero()
h2 = Hero()

コンストラクタの定義

コンストラクタというのは実際Pythonでは存在しないのですが、初期化用のメソッドだと考えてください
クラスの中で定義された関数をメソッドと呼びます。

インスタンス変数

インスタンス変数にアクセスするには、「インスタンス.変数名」とします。

s.a # インスタンス変数aにアクセス
s.b # インスタンス変数bにアクセス

class Sample:

  # クラス変数
  class_val = "これはクラス変数"

  # コンストラクタ(初期化メソッド）
  def __init__(self, a, b):
    self.a  = a    # インスタンス変数
    self.b  = b    # インスタンス変数
    self.li = []   # インスタンス変数

  # メソッド（インスタンスメソッド）
  def hello(self, a):
    print(a)

  # メソッド（インスタンスメソッド）
  def add(self, li):
    self.li = li
# インスタンス化
# sはインスタンス変数と呼ぶ
s = Sample("Apple", "banana")
s2 = Sample("Apple2", "banana2")

print(s.a) # インスタンス変数aにアクセス
print(s.b) # インスタンス変数bにアクセス

メソッド（インスタンスメソッド）

メソッドはクラスの中で定義された関数のことです。
メソッドの定義ですが、下記になります。

def メソッド名(self, 引数2, 引数3, ...):
    処理

メソッドの場合、第一引数は「self」です。これは省略できないので忘れず定義しましょう。
selfとは何かを説明するとそれだけで話が長くなってしまいますので、気になった方は調べてみてください。
今の段階では、第一引数には「self」を必ず指定しないといけないものだというのだけ覚えてください。

class Sample:

  # コンストラクタ
  def __init__(self, a, b):
    self.a  = a    # インスタンス変数
    self.b  = b    # インスタンス変数
    self.li = []   # インスタンス変数

  def hello(self, name):
    print("hello ", name)

# インスタンス化
# sはインスタンス変数と呼ぶ
s = Sample("Apple", "banana")
# メソッド呼び出し
s.hello("tom")

クラスメソッド

クラスメソッドの場合、第一引数は「cls」です。これは省略できないので忘れず定義しましょう。

@classmethod
def クラスメソッド名(clas, 引数2, 引数3, ...):
    処理

class Sample:

  # クラス変数
  class_val = "これはクラス変数"

  @classmethod
  def sample(cls):
    print("クラスメソッドです")

  # コンストラクタ
  def __init__(self, a, b):
    self.a  = a    # インスタンス変数
    self.b  = b    # インスタンス変数
    self.li = []   # インスタンス変数

  def hello(self, a):
    print(a)

  def add(self, li):
    self.li = li
# インスタンス化
# sはインスタンス変数と呼ぶ
s = Sample("Apple", "banana")
s2 = Sample("Apple2", "banana2")
# メソッド
s.add("a")
s2.add("b")
print(s.li)
print(s2.li)

継承

継承は既存のクラスを拡張し、新たにクラスを定義する方法です。
例えば、下記はSampleというクラス（スーパークラスや親クラスなどと呼ぶ）を元に、クラスB（サブクラスや子クラスなどと呼ぶ）を作る場合、Sampleクラスを継承して、クラスBを作ることが可能です。

この場合、継承することで、クラスBは継承したタイミングで、Sampleクラスのクラス変数やインスタンス変数、インスタンスメソッドなど既に定義されたクラスメンバー（クラス変数、クラスメソッド）やインスタンスメンバー（インスタンス変数、インスタンスメソッド）など利用することが可能になります。

class Sample:

  # クラス変数
  class_val = "これはクラス変数"

  # コンストラクタ
  def __init__(self, a, b):
    self.a  = a    # インスタンス変数
    self.b  = b    # インスタンス変数
    self.li = []   # インスタンス変数

  def hello(self, a):
    print(a)

  def add(self, li):
    self.li = li
# インスタンス化
# sはインスタンス変数と呼ぶ
s = Sample("Apple", "banana")
s2 = Sample("Apple2", "banana2")
# メソッド
s.add("a")
s2.add("b")
print(s.li)
print(s2.li)

# 継承
class B(Sample):
  # コンストラクタ
  def __init__(self, a, b):
    super().__init__(a,b)
    # super()使わず下記でも可能
    # self.a  = a    # インスタンス変数
    # self.b  = b    # インスタンス変数
    self.li = []   # インスタンス変数

b = B("b_apple", "b_banana")

# print(type(b))
b.hello("hello")

ポリモーフィズムを実現するための「メソッドのオーバーライド」を使ってください。

総合演習問題

1)2017年から2021年までの要素を持ったyears_listという名前のリストを作ってください。
2)years_listから今年の年を取り出して、printで出力してください
3)years_listから2021年をprintで出力してください

1. 3 2 1 Go! と出力するプログラムをfor文を使って記述してください

2. 0〜9までの値を自乗して出力するプログラムをfor文を使って作成してください。
   

3. 1〜100までの数字の中から偶数の値を持つ値のListをfor文を使って作成してください。

4. 2つの整数値を受け取り、その平均を返すaverage関数を作ってください。また関数を作ったら呼び出して使って見てください。

5. FizzBuzz問題

以下の仕様に従い、FizzBuzzプログラムを作成してください。
・1から100まで順番に数字を出力
・もし、3で割り切れる時は「Fizz」と出力
・もし、5で割り切れる時は「Buzz」と出力
・3と5で割り切れる時は「FizzBuzz」と出力

総合演習問題解答例

1)〜8)全て解けた方、ご確認ください！
それまでは自力で頑張ってみてください。
どうしてもわからない方は以下のリンクに各問題の模範解答プログラムを載せております。
http://qiita.com/AI_Academy/private/278b2bed2887746c0c35

これからの学習へ向けて

ここまで見た内容はあくまでのプログラミングの基本構文です。
さらに力をつけるには、自分の目的に応じたモジュールを学ぶことです。
また中級者になるには、正規表現やアルゴリズムとデータ構造、パッケージ管理やバージョン管理、オブジェクト指向などもしっかりと学ぶ必要があります。
引き続き、プログラミングライフをお楽しみください！

AI Academy（エーアイ アカデミー）

オンラインによるマンツーマンレッスンでAIプログラミングが学べるスクール。
AI Academy 「AI(人工知能)技術をかつてないほどに多くの人々にとって身近にし、AI時代にAIを活用できる人材を創出する」 ことを掲げ、AIエンジニア育成をしている。

AI Academy Community

AI Academy CommunityはオープンなFacebookグループです。
AIに関する情報をお届けします。 定期的にAIに関する情報を知りたい方は、是非参加してください！ お待ちしております！ https://www.facebook.com/groups/1892746874314837/

※参加するには、Facebookアカウントが必要です。