ここではPythonというプログラミング言語について学びます

• Pythonの基本
• 文字列と数
• 式と値
• キーボード入力
• 型と型変換
• 条件分岐
• 比較演算子
• 繰り返しの基本を学ぶ
• Pythonのデータ構造：リスト、辞書、タプル
• 関数
• ファイルの入出力
• クラス

Pythonの基本

Pythonのプログラムを実行するにはいくつかの方法があります。

• プログラムをTeraPadや秀丸エディタのようなエディタを使ってファイルに書きこんでおきます。 そのファイルの名前を仮にtest.pyとすると(pyという拡張子は、 これがPythonのプログラムのファイルであることを表します）、 そのファイルをマウスでダブルクリックすれば実行できます。
  ただ、この方法だと、実行結果がみえない（実行終了後、すぐにウィンドウが消えてしまう）ことがある、という欠点があります。
• 先と同様に、プログラムをファイルとして書き込みます(ここでも仮に test.pyという名前としておきます)。 そして、コマンドプロンプト(「すべてのプログラム」→ 「アクセサリ」→ 「コマンドプロンプト」)を開き、 cdコマンドを使って そのファイルがあるディレクトリに移動します。 例えば、演習室のコンピュータを使っていて、プログラムのファイルをデスクトップにおいたとすれば、

  cd .NT\_Desktop
  

  によって、ワーキングディレクトリがデスクトップにセットされます。 その後 python test.pyを実行します (注意: pythonとtest.pyの間に半角のスペースが必要です)。
• コマンドプロンプトを開きます。 pythonコマンドを入力します。 同時にエディタを開いておきます。 まずエディタでプログラムの一部を入力し、コピーアンドペーストを用いて それをpythonで実行します。 エラーが起きたら、エディタで修正した後に、pythonで実行しなおします。

もっともIDLEやspyderが使える環境にあれば、それを使ってみるのも良いでしょう。

最初のPythonプログラム

print ("hello, world!")

python first.py

hello, world!

printというのがPythonの関数の一つで、画面に引数の値を表示する、というものです。そして、"hello, world!" の部分がその引数です。Pythonは、数だけではなく、このような「文字列」を扱うことが簡単にできます。ここで文字列とは、 " "、つまり引用符号（ダブルクォート、もしくは二重引用符と言います。）で囲まれている文字の並びのことです。

python

>>> 

print ("こんにちは")

こんにちは
>>> 

日本語の扱いはどんなプログラミング言語でも少しやっかいです。しかし、 unicodeが今や事実上の標準コーディングになった今、少し扱いやすくなりました (とは言っても、今見たように文字化けすることがありますから注意しましょう)。 文字化けした場合は、次のように入力して最後にEnterキーを押してください。

print (u"こんにちは")

[プログラムファイルにおけるコーディングの問題]

print (u"こんにちは")

さて、pythonを起動したあと、次は以下を試してみてください。

a=u"こんにちは"
print (a)

このようにPythonの特徴の一つは、変数は(定数も)宣言なしに使え、しかもどんな型のオブジェクトも代入できる、ということです。たとえば、続けて次のようにしても怒られません。 (以下の例は、さっきは文字列を値とした変数aに、今度は数を代入しようとするものです)

a = 12345679 * 9
print (a*8 )

ここで起動したpythonを終了させる言葉を書きます。それはquit()です(exit()でも同じことができます)。

文字列と数

これまでは、プログラムの中で、文字列という種類の対象だけを扱ってきましたが、 ここでは、プログラムで数も扱うことにしましょう。 数に対しても、文字列について今まで学んできたことがあてはまります。 つまり、変数への数の代入や変数からの数の取り出しなども全く同じような操作でできます。 ただし、数は文字列と違って、プログラムの中ではそのまま書けば意味を持ちます。 （注意: 引用符で囲むと、数ではなく文字列として扱われます。）

num = 1000
print (num, u"\n")

print(u"ここにはタブがありません")
print(u"ここに\tタブが2つ\tあります")

式と値

これまで、変数を単独で扱ってきましたが、変数や文字列、数を要素にして、 式を作ることができます。
例えば、次のプログラムの中の num1 + num2 は式の例です。

num1 = 1000
num2 = 2000
wa = num1 + num2
print ( wa)

このように、プログラムの構成要素として「式」があります。 簡単な式を組み合わせてより複雑な式が構成できるというのは、一般の数式の場合と同じです。

num1 = 1000
num2 = 2000
kekka = (num1 + num2) * num2    # * は掛算を表す記号です。
print ( kekka)

式は変数と同様に「式全体」で値を持ちます。 値を持つプログラムの構成要素を式だと言ってもよいでしょう。
文字列を対象にした式も作れます。
たとえば次のように、文字列を + で結合したものも式です。この式を実行すると、それらが結合 された文字列が式の値になります。

kotoba = "Hello, " + "Mr. Taro!"
print ( kotoba)

もう少し詳しく、プログラムの実行過程を見ていきましょう。 上のプログラムを実行すると、まず1行目の命令が実行されるのは当然ですね。 このような実行されるプログラムの構成単位を文と呼びます。 命令が言葉の集まりとして構成されているからです。 一行目は、変数への代入を行う命令ですから、「代入文」と呼ぶこともあります。 代入文は、等号(=)の右辺の式を実行し、その結果の値を等号の左辺にかかれた変数に代入するものです。 さて、この代入文は今までに出てきた単純な代入文とは違って、右辺が式になっています。

kotoba = "Hello, " + "Mr. Taro!"

"Hello, " + "Mr. Taro!"

となっていて、文字列が「 + 」の記号で繋がっている式です。 このように文字列を演算の対象とする「 + 」は二つの文字列をつなげるという働きをします。 この式を実行すると、二つの文字列が繋がって一つの文字列、

"Hello, Mr. Taro!" 

が出来上がり、これが式の値になります。 そして「 = 」を使う代入文は右辺の式の値を左辺の変数に代入するということになりますから、 文字列"Hello, Mr. Taro!" がkotobaという変数に代入され、この変数の値になります。

キーボード入力

次のプログラムでは、キーボードからの入力を受け取るための命令文が使われています。 input() がその命令文です。 この命令文が実行されるとキーボードからの入力を待つ状態になります。 文字が入力されるとプログラムの実行を再開し、受け取った文字列をプログラムの 中で扱うことができるようになります。 次のプログラムでは、入力された文字列を aisatsu という変数に代入しています。
まずはこのプログラムをコピーし、utf-8に文字コードを変換したaisatsu.pyというファイルを作り、 python aisatsu.py を実行して、キーボードからの入力を受け取れていることを確認してみましょう。 ここで、「あいさつ：」と表示された後に「こんにちは」などの文字列を入力して、Enterキー を押してください。 ちなみに、コマンドプロンプトで日本語を使うときは (Altキー を押しながら )半角/全角キーを押します。また半角文字モードに戻すのも、(Altキー を押しながら )半角/全角キーを押します。

# -*- coding: utf-8 -*-
# pythonに utf-8を使っていることを知らせる---日本語の扱いには必要

print (u"あいさつ：", end="")     # end=""によって改行されない
aisatsu = input()

print ("\n")
print (aisatsu, u"。お元気ですか？")

print (u"あいさつ：",end="") ; aisatsu = input()

print (aisatsu, u"。お元気ですか？")

こんにちは 。お元気ですか？                   # 先の課題で「こんにちは」を入力した場合

参考：inputは引数を取れ、この引数はプロンプトとして表示される。 だから今の例は以下のようにもかける:

aisatsu = input("あいさつ: ")
print (aisatsu + "お元気ですか？")

名前：中京太郎
あいさつ：こんにちは

中京太郎さん、こんにちは。
お元気ですか？

お会計：10000
人数：3

お一人様3333円です。
不足金額は1円です。

kaikei = int(input())

print (10000 / 3)

3333.3333333333335

kaikei = 10000

print (kaikei / 3)

3333.3333333333335

print (kaikei // 3)

print (10000 % 3)

1

num = 10

num = num + 10
print (num)

num = num * 10
print (num)

num = num - 150
print (num)

num = num // 20
print (num)

num = num ** 2
print (num)

print (1000 * 3)

3000

num = 1000

print (num * 3)

3000

print (2 ** 10)

1024

長方形の面積を計算します。
縦と横の辺の長さを入力してください。
縦：10
横：20
長方形の面積は 200 です。

print ("年齢を整数でキーボードから入力してください。")
nenrei = int(input())                       #ここで、20を入力することにする。
print ("あなたの年齢は", nenrei, u"才です。")

mojiretsu = "20"
kazu = 20
print (mojiretsu == kazu)

mojiretsu = "20"
kazu = 20
goukei = mojiretsu + kazu
print (goukei)

mojiretsu = "20"
kazu = 20
goukei = int(mojiretsu) + kazu
print (goukei)

変数の値の更新

>>>  a = 10
>>>  a += 5
>>>  print ('a = ', a)
a = 15
>>>  a *= 10
>>>  print ('a = ', a)
a = 150
>>>  a /= 5
>>>  print ('a = ', a)
a = 30
>>>  a %= 8
>>>  print ('a = ', a)
a = 6
>>>  a **= 2
>>>  print ('a = ', a)
a = 36

型と型変換

数には整数と実数とがあります。整数はintと表記され、実数は「浮動小数点数」と呼ばれ、floatと表記されます(プログラミング言語Cと同じ表記です)。変数の値がどの型のものかを調べるにはtypeという関数があります。

x = 'Hello, World!'
type(x)
x = 3
type(x)
x = 3.14159265
type(x)

Pythonには、値を本来の型から別の型にする関数が用意されています。前に述べたint 関数は、任意の値をとり、整数に変換します。ただし、整数に変換できない場合にはエラーとなります。

>>> int('32')
32
>>> int('hello')
ValueError: invalid literal for int() with base 10: 'hello'
>>> int(3.14)
3
>>> int(-2.3)
-2

>>> float(32)
32.0
>>> float('3.14159')
3.14159

>>> str(32)
'32'
>>> str(3.14159)
'3.14159'

条件分岐

条件分岐とは、次のように状況を判断して、適切な反応ができるようなプログラムの仕組みです。 次のコンピュータとの対話例を見てください。

コンピュータ：あなたの年齢はいくつですか？（年齢を数字で入力してください。)
年齢:19
コンピュータ：残念ですが、まだ、お酒を飲んではいけない年齢ですね。

年齢に20を入力すると、

コンピュータ：あなたの年齢はいくつですか？（年齢を数字で入力してください。)
年齢:20
コンピュータ：おめでとう。もう、お酒を飲める年齢ですね。

このように、入力によって違う応答を返すことができます。

このようなやりとりを実現するためには、入力された年齢(これは数として扱います)によって、 コンピュータに異なる振る舞いをさせるプログラムを作成する必要があります。 そのためには次のような、ifの構文を使った、条件分岐の仕組みが必要です。注意:if文とelse文の後にはコロン（：）が必要です。またそれぞれの文の前にはきっちり同じだけのスペースを置く(インデントする)ことにも気をつけましょう。
[コロンとインデントの意味]

#include <stdio.h>
int main(void) {
  int nenrei;
  printf("コンピュータ：あなたの年齢はいくつですか？（年齢を数字で入力してください。)\n");
  printf("年齢:");
  scanf("%d", &nenrei);
  if (nenrei < 20) {		// if文の始まり
	printf("コンピュータ：残念ですが、まだ、お酒を飲んではいけない年齢ですね。\n");
  } else {			// if文の終わりとelse文の始まり
	printf("コンピュータ：おめでとう。もう、お酒を飲める年齢ですね。\n");
  }				// else文の終わり
  return(0);
}

if (条件判定式):
  文
  文
  ...
else:
  文
  文
  ...

print (u"コンピュータ：あなたの年齢はいくつですか？（年齢を数字で入力してください。)")
print (u"年齢:",)
nenrei = int(input())

if (nenrei < 20):
  print (u"コンピュータ：残念ですが、まだ、お酒を飲んではいけない年齢ですね。")
else:
  print (u"コンピュータ：おめでとう。もう、お酒を飲める年齢ですね。")

条件分岐は強力な仕組みです。 コンピューターが人間のための強力な道具になるのは、 このように場面に応じて適切に動作するようにプログラムできるからである、 と言っても言い過ぎではないでしょう。 知的な振る舞い、つまり適切な場面で適切な動作をさせる根源にこの「条件分岐」があるのです。
ifで作られる条件分岐のプログラムの、基本の形は次のようなものです。

if (条件判定式):
  #上の括弧の中の条件判定式の実行結果が真のときだけ以下の文が次々に実行される。
  文 
  文
  ...
else:
  #上の括弧の中の条件判定式の実行結果が真でないときだけ以下の文が次々に実行される。
  文
  文
  ...

print (u"コンピュータ：あなたの年齢はいくつですか？（年齢を数字で入力してください。)")
print (u"年齢:")
nenrei = int(input())         #キーボードから19という数が入力されると...

if (nenrei < 20):
  print (u"コンピュータ：残念ですが、まだ、お酒を飲んではいけない年齢ですね。")
else:
  print (u"コンピュータ：おめでとう。もう、お酒を飲める年齢ですね。")

ifの括弧の中の条件判定式が問題です。 この括弧の中の「条件」が判定され、合っていればすぐ下の部分が実行されます。 条件に合っていない場合は、elseの下に書かれた部分が実行されます。

条件判定式について詳しく見てみましょう。 条件判定式の部分が、実際に実行されることに注意してください。 実行されると値を持つのが式でした。 条件判定式も式ですので、実行されるとその値が求められます。 上の条件判定式の場合、nenrei < 20 という式がまず実行され、「19は20より小さい」という意味に合致しますので、Trueという値がこの式の値になります。 Trueというのは、条件判定式が正しいことを表す値です。 反対に、条件判定式が間違っている場合はFalseという値で表されます。

式の値として、これまでは文字列と数だけを扱ってきましたが、 これからは真を表すTrueと偽を表すFalseも扱うことになります。これらは「真偽値」と呼ばれます。文字列と数とは違う「第３の」種類の値です。 今度はこの部分だけを、詳しく見てみましょう。

nenrei = 19
print (nenrei < 20)

print ("\n")

nenrei = 21
print (nenrei < 20)

print (u"こんにちは"    #文字列)
print (100             #数)
print (True            #True)
print (False         #False)

こんにちは
100
True
False

#文字列の連結
print ("Hello, u" + "Mr. " + "Taro Chukyo")

#数の計算
print (100 * 2)

Hello, Mr. Taro Chukyo
200

nenrei = 19
print (nenrei <20)

nenrei = 21
print (nenrei < 20)

比較演算子

if文の条件判定式で使用する < や > のことを比較演算子と呼びます。 比較演算子には次のような種類があります。

  

    
a == b
aとbは等しい
  
  
  

    
a != b
aとbは等しくない
  
  

    
a < b
aはbより小さい
  
  

    
a > b
aはbより大きい
  
  

    
a <= b
aはb以下
  
  

    
a >= b
aはb以上
  

思いついた整数をキーボードから入力し、最後にエンターキーを押してください。

数：19

その数は奇数です


思いついた整数をキーボードから入力し、最後にエンターキーを押してください。

数：12

その数は偶数です

ランダムな数の生成

randomint(min,max)は最小値min、最大値maxの間の整数をランダムに発生させる乱数生成関数です 。ただしこの関数をつかえるようにするには、次の命令を初めに実行する必要があります:

from random import randint

import random
from random import randint
from random import *

次の課題で、さいころの目を出すプログラムをこのrandint関数で実現してみましょう。

H:>Python program.py
さいころを振ります！
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
         #0.5秒待つ。
さいころの目は3でした。

H:>Python program.py
さいころを振ります！
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
         #0.5秒待つ。
さいころの目は5でした。

from time import sleep

print (u"コロ,,,")
sleep(0.3)
print (u"コロ,,,")

#当たった時
さいころゲームの始まりです！
次に振ったさいころの目を当てましょう。
次にでる目はなんですか？
予測：5
では振ります。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
サイコロの目は？  #0.5秒待つ。
5 でした！
大当たりです! 超能力をもっていますね。

#はずれた時
さいころゲームの始まりです！
次に振ったさいころの目を当てましょう。
次にでる目はなんですか？
予測：5
では降ります。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
コロ,,,  #0.3秒づつ待つ。
サイコロの目は？  #0.5秒待つ。
2 でした！
残念でした。また挑戦してくださいね。

より複雑な条件分岐（if文）を理解する

if (条件判定式):
    文1
    文2
    ...
else:
    文100
    文101
    ...

nenrei = 21

if (nenrei >= 18):
  print (u"あなたは車の免許を取ることができます。")
else:
  print (u"あなたはまだ車の免許を取ることができる年齢に達していません。")

さて、基本は同じですが、もう少し複雑なif文を見てみましょう。 if文全体も一つの文ですから、次のようにif文の実行式1のところに、if文を入れることで、つぎのようにより複雑な分岐を実現することができます。 Pythonプログラムとして、内側のif文はさらに何文字分かスペースを前にいれることが大事です。

  if (条件判定式):        # 最初のif。この前に2個のスペースがあるとする
    if (条件判定式):         # 最初のifの中のif文。4個のスペースを置く 
      文			        # 2番目のif文が真の場合に実行される文。スペースを6個置く 
      文			        # 2番目のif文が真の場合に実行される文。スペースを6個置く 
      ...
    else:	             # 2番目のif文と対になるelse文. if文と同じ4個のスペースを置く 
      文                                # else文を構成する文。6個のスペースを置く
      文
      ...                               # else文を構成する最後の文
  else: 	          # 1番目のif文と対になるelse文. if文と同じ2個のスペースを置く 
    文                       # else文を構成する文>
    文
    ...                      # else文を構成する最後の文>

次のようなプログラムがその具体的な応用例です(ここでは先頭のif文の前にはスペースはありません):

# -*- coding: utf-8 -*-
print (u"年齢を数字でキーボードから入力してください。")
nenrei = int(input())

if (nenrei >= 18):
  if (nenrei >=20):
    print (u"あなたは車の免許を取ることができます。")
    print (u"あなたはお酒も飲むこもできます。")
    print (u"よかったですね!")
  else:
    print (u"あなたは車の免許を取ることができます。")
    print (u"しかし、あなたはお酒を飲むことは法律で禁じられています。")
    print (u"残念でしたね!")
  # if (nenrei >= 20)
else:
  print (u"あなたは残念ながらまだ車の免許を取ることができる年齢に達していません。\nお酒も飲んではいけません。")
# if (nenrei >= 18)

if文は自由に組み合わせて構成できますから、さまざまな変形の形があります。 elseがないものも可能です。

if (条件判定式):
  文
  文
  ...

また、次のように、if文の中にif文のつながりがあってもよいことになります。

if (条件判定式):
   if (条件判定式):
     文
     文
     ...
   if (条件判定式):
     文
     文
     ...
   else:
     文
     文
     ...
   文
   文
   ...

# -*- coding: utf-8 -*-
print (u"数を入力してください> ",)
kazu = int(input())

if (kazu == 1):
  print (u"☆")
else:
  if (kazu == 2):
      print (u"☆☆")
  else:
    if (kazu == 3):
        print (u"☆☆☆")
    else:
      if (kazu == 4):
        print (u"☆☆☆☆")
      else:
        print (u"★")
      # if (kazu == 4) ... else
    # if (kazu == 3) ... else
  # if (kazu == 2) ... else
# if (kazu == 1) ... else

elif文

if (kazu == 1):
  文1
else:
  if (kazu == 2):
    文2
  else:
    if (kazu == 3):
        文3
    else:
      if (kazu == 4):
        文4
      else:
        文5
      # if (kazu == 4) ... else
    # if (kazu == 3) ... else
  # if (kazu == 2) ... else
# if (kazu == 1) ... else

if (kazu == 1):
  文1		# kazu==1の場合に実行される
elif (kazu == 2):
  文2		# kazu==2の場合に実行される
elif (kazu == 3):
  文3		# kazu==3の場合に実行される
elif (kazu == 4):
  文4		# kazu==4の場合に実行される
else:
  文5		# それ以外の場合に実行される
# if ... else文の終わり

繰り返しの基本を学ぶ

プログラミングをする上で頻繁に使う最も重要な基本パターン は「繰り返し」の構造だと 言っても言い過ぎではないでしょう。 コンピューターが強力な道具であるのは、それが高速であるため ですが、その高速性を生かして役に立つ道具にするためには、これから説明する 「繰り返し」の構造が本質的な役割を果たしています。 現実のほとんどのプログラムが繰り返し構造を使っていると言ってもよいでしょう。

次のように、「こんにちは」を10回表示するプログラムを考えてみましょう。

こんにちは
こんにちは
こんにちは
こんにちは
こんにちは
こんにちは
こんにちは
こんにちは
こんにちは
こんにちは

これまでは、print文を10個書く必要がありました。

print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")
print (u"こんにちは")

繰り返し構造を実現するforやwhile を使うことで、上のプログラムを次のように短く簡潔に書くことができます。

• forを使ったプログラム
  

  for i in range(10):
    print (u"こんにちは")
  # for 
  

• whileを使ったプログラム
  

  i = 0
  while (i < 10):
    print (u"こんにちは")
    i = i + 1
  # while文の終わり 
  

なぜ、これでうまくいくのか、その仕組みを理解しましょう。 仕組みを理解することは大事です。 そうしないと、大事なくり返しの構文を自由自在に使いこなせないからです。

２種類の繰り返し: forとwhileの特徴

Pythonではいろいろな種類の「繰り返し」の構文が用意されています。 その中でforとwhile はとても重要です。これは２つの違う考えに基づく繰り返しを実現するからです。

forは、「ある決まった回数だけ」 （もしくは決まった個数の対象に対してだけ）、命令を繰り返します。 今の例はprint命令を10回繰り返すという問題でしたから、for文を使うには最適の問題でした。

whileは、「ある条件が成り立っている間」だけ命令を繰り返します。 今の例はprint命令を10回繰り返すという問題でしたから、while文を使うにはあまり適さない問題でした。

for文の仕組み

for 変数 in 変数の取りうる範囲の指定:
     文1
     文2
     ...
# for 文の終わり 

ここで「変数の取りうる範囲の指定」によく用いられる関数rangeについて簡単に説明します。forの中のrangeはrange(n)のように引数1個(nは正整数)で使われると、最小値0、最大値n-1までの範囲の整数を返します(要するに、n個の整数が返されます)。また、 range(min,max)のように引数2個(min < max、整数でないといけない)で使われると、最小値min、最大値max-1までの整数を返します。

ですからこのfor文を実行すると、次のように動作が行われます。

1. まず変数の値として「変数の取りうる範囲の最小値」が与えられる。
2. 変数の値が「変数の取りうる範囲の上限値」以上であれば、for全体の実行を終える。
3. 文1, 文2, ...が順番に実行される。
4. 変数の値に1が足され、プログラムの実行が2.に戻り、もう一度同じことが繰り返される。

for i in range(10):
  print (i+1, u"回目のこんにちは")
# for 

ここで変数としてiを使いましたが、変数として使えるものならなんでも構いません。 ただこの変数がないと、繰り返しはうまく機能しません。 なお、変数iのとりうる範囲をrange(10)と書いていますが、これはもちろん 最小値が0，上限値が10であることを表しています。 ちなみに、単に10回「こんにちは」をprintするだけでしたら、 最小値が1001で最大値が1010でも構いません(変数iがとる値は1001から1010までの10通り）。 実際、次のようにも書けます(が、プログラムがわかりにくくなりますので、普通はやりません）。

for i in range(1001,1011):
  print (u"こんにちは")
# for 文の終わり

2
4
6
8
10
12
14
16
18
20

20
18
16
14
12
10
8
6
4
2

>>> range(1,10,2)                    # >>>はPythonのプロンプト
[1, 3, 5, 7, 9]
>>> range(10,-5,-2) 
[10, 8, 6, 4, 2, 0, -2, -4]

while文の仕組み

while (条件判定式):
  文1
  文2
  ...
# while文の終わり 

whileを実行すると次のように動作します。

1. まずif文と同様、条件判定式が実行され、その値が取り出される。
  1-1. 条件判定式の値が真の時、
         その下の文1、文2などが順番に実行される。(この辺りはif文と同じです。)
         while文の最後まで来ると、プログラムの実行場所がwhileの先頭に戻る。
         （1. に戻り、条件判定式がもう一度実行され、同じことが繰り返される。）
  1-2. 条件判定式の値が偽の時、
         何もしないで、while全体の実行を終える。（2. に進む。）
2. while文の次の文から実行を再開する。

先ほどの「こんにちは」を10回表示するプログラムをwhile構文を使って書くには、 表示される回数を数えるための変数が必要になります。以下ではその変数として iを用いています。そして、while文の前に変数iに0を与え、 表示が終わるごとにiに1を足すようにしています。変数iの値の変化に着目してください。

i = 0          #iの値は0。
while (i < 10):
  print (u"こんにちは")
  i = i + 1    #iの値を1つ増やす。
# while 文の終わり

10回繰り返して、そこで終わりになるのは、繰り返すたびごとにiの値が1ずつ増えていることと、 条件判定式 (i < 10) のおかげです。 10回繰り返すまでは、iの値は10より小さいので、条件判定式が真となり、繰り返しを行うことになります。 10回以上になると、条件判定式が偽となりますので、whileの実行を止めることになります。
このように、回数を記憶するための変数 (このような変数をカウンター変数と呼びます）には、 whileの繰り返しに入る前に0などの数を代入しておく必要があります。 この変数の働きがないと、while文を使ってある一定の回数繰り返す、というプログラムはうまく機能しません。

3
9
27
81
243

20
18
16
14
12
10
8
6
4
2

数の合計を計算します。数を入力してください。
最小値：10
最大値：30
10から30までの数の合計は420です。

コンピュータ：自然数nの階乗の計算を行います。nをキーボードから入力し、Enterキーを押してください。
n:20
結果：20の階乗は2432902008176640000です。

n * (n-1) * (n-2) * ... * 3 * 2 * 1 
これを数学では n! と書きます。
例
5! = 5 * 4 * 3 * 2 * 1 = 120

無限に繰り返す

回数を限定しないで繰り返すためには、

while (True):
  ...
  ...
  ...
# while文の終わり 

というような形が使えます。条件判定式の中が常にTrue(真)なので、終わりません。

このような「終わらない」while文は上の形以外にも、カウンタ変数の更新式 (i=i+1のような式)を書き忘れた場合に出現します。 これを無限ループと言います。無限ループに陥ったプログラムを止めるのは コントロールC(Ctrlキーを押したままCを押す, Ctrl-Cと書く）です。以下を実行し、プログラムをCtrl-Cで止めてみましょう。

while(True): print(".")

Pythonのデータ構造

文字列

>>>  x = "John's store"				# "と"でくくられた文字列の中に'を書く場合
>>>  y = 'Mary\'s favorite fruit'		# 'と'でくくられた文字列の中に'を書く場合
>>>  print ( "I bought ", y, " at ", x)
I bought Mary's favorite fruit at John's store

>>>  len('abc')
3
>>>  len('')
0

>>>  fruit = 'apple'
>>>  fruit[0]
'a'

>>>  fruit[-1]
'e'

>>>  fruit[2:4]		# 2文字目から(4-1)=3文字目までの部分文字列
'pl'
>>>  fruit[:2]		# 先頭(0文字目)から(2-1=)1文字目までの部分文字列
'ap'
>>>  fruit[2:]		# 2文字目以降の部分文字列
'ple'

>>>  fruit[2] = 'o'		# 2文字目を'o'で置き換えようとする
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'str' object does not support item assignment

>>>  str(2*5)
'10'
>>>  str([2,5])					# [2,5]はリスト
'[2, 5]'
>>>  str((1,2,3))				# (1,2,3)はタプル
'(1,2,3)'

>>>  int(' 3 ')		# 整数の文字列
3
>>>  int('3.14')		# 実数の文字列はエラーになる
Traceback (most recent call last):
  File "", line 1, in 
ValueError: invalid literal for int() with base 10: '3.14'
>>>  int('3A',16)		# 第2引数として16を指定すると、16進数表示と解釈される
58
>>>  float('3.14')		# intの場合はエラーになるがfloatの場合は実数に変換される
3.14

リスト

ここではリスト（Cにおける配列に相当)について学びます。 リストはプログラミングには欠かせない最も重要な基本要素、 基本的な「データ構造」の一つです。 リストをマスターしない限り、現実のプログラミングはできないと言っても言い過ぎではありません。 繰り返しがコンピューターの力のもとだといいましたが、リストと一緒に使うことで、 コンピューターはますます強力になると言ってもよいでしょう。

それでは、リストとはどんなものでしょうか。たくさんのものをしまったり出したりできる、便利な入れ物です。ここまでは変数と同じように、入れ物として働いているだけですが、変数と違って、一つだけではなく、たくさんのものを入れたり出したりして処理することができます。 変数の集まりであると考えることもできます。 変数に値を入れることができるということは、変数がいろいろな値を取れるということになります。 （変数という言葉の由来です。）リストは複数の変数の集まりと見ることができ、したがって、複数の値を扱うことができるのです。 変数は変数名によって保持している値を扱いますが、 リストでは、次に述べるような形で、名前で直接値を扱うのではなく、指標（インデックス）といわれる数によって、 値を扱うことができるのです。これが変数をとても便利に使える大きな理由の一つでしょう。 このようなことが何を意味するのか、下の例で一歩、一歩見て行きましょう。

リストの特徴を複数の変数を使う場合と対比してしてみましょう。いつくもの名前と挨拶を扱うプログラムを、リストを使わないで、変数だけで作ってみましょう。 まず、用意した nameA,nameB,nameC,nameD,nameEという5個の変数に、 名前を表す文字列を代入しておきます。それを次々に出力していくことにします。

nameA = u"太郎"
nameB = u"紘美"
nameC = u"克規"
nameD = u"倫哉"
nameE = u"隆弘"

#ここまでで、変数への名前の代入ができました。
#これから後は出力です。

print (u"こんにちは、", nameA, u"さん")
print (u"こんにちは、", nameB, u"さん")
print (u"こんにちは、", nameC, u"さん")
print (u"こんにちは、", nameD, u"さん")
print (u"こんにちは、", nameE, u"さん")

今度は、変数ではなく、リストの中に上の５個の名前を入れます。 まず、nameという変数を用意します。そして変数nameに、今の要素を値とするリストを代入します。これは、次のようにすればできます。

name = [u"太郎", u"紘美", u"秀樹", u"倫哉", u"隆弘"]      #  変数nameにリストを代入

>>> for i in range(len(name)):
....   print (u"こんにちは、", name[i], u"さん")         # .... は継続行であることを表す
こんにちは、太郎さん
こんにちは、紘美さん
こんにちは、秀樹さん
こんにちは、倫哉さん
こんにちは、隆弘さん

指標は0以上の整数であることに注意してください。 これは、リストが0番から始まるということであり、 「リストの一番最初の要素の指標が0」ということです。

ここで、

print (name[2])

秀樹

それでは次を実行するとどんな出力結果になるでしょう。

name[2]=u"一郎"
print (name[2])

なお、空っぽのリストを用意して、それに次々と要素を付け加えていくことでも、同じことが実現できます。

name = []                        # 空っぽのリスト
name.append(u"太郎")             # "太郎"を付け加える
name.append(u"紘美")             # "紘美"を付け加える
name.append(u"秀樹")             # 以下同様
name.append(u"倫哉")  
name.append(u"隆弘")  

name  = []

name[0] = u"太郎" 
name[1] = u"紘美" 
name[2] = u"秀樹" 
name[3] = u"倫哉"
name[4] = u"隆弘"

i = 3
print (name[i])

リストがプログラミングの強力な道具になるのは、数（指標)によってリストの内容を取り出せるからです。 forやwhileの繰り返し文と組み合わせて使うことでリストは特に便利になります。

リストには、文字列に限らず何でも、入れることができます。 （変数に何でも入るのと同じです。）数を扱ってみましょう。

data = [2,4,7,3,9,6,4,4,10,23,1,1,1,7,8,6,25,30,30,9] 

data = [2,4,7,3,9,6,4,4,10,23,1,1,1,7,8,6,25,30,30,9] 

print (len(data))

print (data[0])
print (data[4])
i = 5
print (data[i])
print (data[i+3])

data = [2,4,7,3,9,6,4,4,10,23,1,1,1,7,8,6,25,30,30,9] 

2
4
7
3
#（中略）
30
9

data = [2,4,7,3,9,6,4,4,10,23,1,1,1,7,8,6,25,30,30,9] 

total = 0
for i in len(data):
  total = data[i]
# for

print (u"リストの合計は", total, u"です。")

リストの合計は190です。

for再訪---リストとの組み合わせ

リストはfor文を使うと、簡単に扱えることがあります。次のような形で扱います。

data = [e0, e1, ... , en]
for ele in data
  文1
  文2
  ...
# for文の終わり 

for文を理解する上でのポイントは、inの前の変数です。代入文が明示されていませんが、 リストの中からその要素が一つ一つ取り出されては、eleに代入され、実行されることを繰り返します。

何回繰り返し実行されるのかという回数は、リストの要素の数と同じになるのは当然です。このような繰り返しのやり方は、指標(インデックス)を使わずにリストの要素を直接扱えるという特徴があります。

>>> range(5)
range(0,5)

>>> list(range(5))
[0,1,2,3,4]

for x in range(5):
   print (x, x**2, x**3)

for x in [0,1,2,3,4]:
   print (x, x**2, x**3)

リストの中から必要なものだけを取り出して処理する

リストの中から必要なものだけを取り出して、処理する形はよくあるプログラムの「パターン」です。 このパターンに慣れておく必要があります。if文とうまく組み合わせることがこつです。

  

    
a == b
aとbは等しい
  
  
  

    
a != b
aとbは等しくない
  
  

    
a < b
aはbより小さい
  
  

    
a > b
aはbより大きい
  
  

    
a <= b
aはb以下
  
  

    
a >= b
aはb以上
  

また、一つの条件式で書けない複雑な条件式（真偽の値の合成）は、 論理演算子と呼ばれるものを使って、条件を組み合わせて表現します。

「かつ」(and)は andで表現され、「または」(or)は or で表されます。 これらは条件と条件の間に書きます。 また、「でない」(否定, not)は not で表し、条件の前に書きます。 プログラミング言語Cで用いられている&& や || や !はPythonでは使えませんので注意してください。

  

    
A and B
AかつB
  
  
  

    
A or B
AまたはB
  
  

    
not A 
Aでない
  

例えば、「numが3以上でかつ10以下」という条件式は、次のようになります。

(num >= 3 and num <= 10)

また、「numが3または10」という条件式は、次のようになります。

(num == 3 or num == 10)

さらに、『「nが3以上で mが10以下」でない』という条件式は、次のようにかけます。

not (n >= 3 and m <= 10)

numbers = [4,12,45,21,18,7,20,5,51,16,10]
#この後の部分を作る

12
18
20
16
10

10以上、20以下の数の合計は76です。

10以上、20以下の数は全部で5個あります。

nekodata = [u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ", u"しろねこ", u"みけねこ", 
 u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"みけねこ",
 u"みけねこ", u"しろねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"みけねこ",
 u"しろねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"しろねこ",
 u"くろねこ", u"しろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"みけねこ",
 u"しろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"くろねこ",
 u"しろねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"くろねこ",
 u"くろねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"みけねこ", u"しろねこ",
 u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"みけねこ", u"みけねこ",
 u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"みけねこ",
 u"しろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"くろねこ", u"しろねこ",
 u"くろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ", u"みけねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"しろねこ",
 u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"みけねこ",
 u"しろねこ", u"くろねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ", u"みけねこ",
 u"しろねこ", u"くろねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"みけねこ", u"しろねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"くろねこ",
 u"みけねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"みけねこ", u"しろねこ",
 u"しろねこ", u"しろねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ", u"くろねこ",
 u"みけねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"くろねこ", u"くろねこ",
 u"くろねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"とらねこ",
 u"しろねこ", u"とらねこ", u"とらねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"とらねこ",
 u"しろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"みけねこ", u"とらねこ",
 u"くろねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ", u"しろねこ",
 u"しろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"みけねこ",
 u"みけねこ", u"とらねこ", u"みけねこ", u"とらねこ", u"みけねこ", u"しろねこ", u"しろねこ",
 u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"みけねこ",
 u"とらねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"くろねこ",
 u"みけねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"くろねこ",
 u"みけねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"くろねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ",
 u"くろねこ", u"しろねこ", u"ばけねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ",
 u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"みけねこ", u"くろねこ",
 u"しろねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"とらねこ", u"しろねこ", u"しろねこ",
 u"みけねこ", u"くろねこ", u"うみねこ", u"しろねこ", u"みけねこ", u"しろねこ", u"みけねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"しろねこ",
 u"くろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"くろねこ", u"みけねこ", u"くろねこ",
 u"みけねこ", u"みけねこ", u"くろねこ", u"とらねこ", u"くろねこ", u"しろねこ", u"しろねこ",
 u"みけねこ", u"しろねこ", u"しろねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ",
 u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ", u"しろねこ", u"しろねこ", u"くろねこ",
 u"くろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"とらねこ", u"しろねこ",
 u"くろねこ", u"みけねこ", u"くろねこ", u"うみねこ", u"しろねこ", u"くろねこ", u"しろねこ",
 u"みけねこ", u"しろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ",
 u"みけねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"くろねこ", u"しろねこ",
 u"みけねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ",
 u"みけねこ", u"くろねこ", u"みけねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"しろねこ",
 u"しろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"しろねこ", u"みけねこ",
 u"しろねこ", u"しろねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"みけねこ",
 u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"くろねこ", u"しろねこ", u"みけねこ",
 u"くろねこ", u"みけねこ", u"みけねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"みけねこ",
 u"くろねこ", u"とらねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"くろねこ",
 u"くろねこ", u"しろねこ", u"くろねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"みけねこ",
 u"みけねこ", u"くろねこ", u"しろねこ", u"みけねこ", u"やまねこ", u"しろねこ", u"しろねこ",
 u"くろねこ", u"しろねこ", u"みけねこ", u"くろねこ", u"くろねこ", u"しろねこ", u"みけねこ",
 u"みけねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"みけねこ", u"しろねこ",
 u"くろねこ", u"みけねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"みけねこ",
 u"とらねこ", u"とらねこ", u"くろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"くろねこ",
 u"しろねこ", u"くろねこ", u"くろねこ", u"くろねこ", u"みけねこ", u"くろねこ", u"しろねこ",
 u"しろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ",
 u"しろねこ", u"しろねこ", u"しろねこ", u"しろねこ", u"しろねこ", u"みけねこ", u"みけねこ",
 u"しろねこ", u"くろねこ", u"あかねこ", u"くろねこ", u"みけねこ", u"みけねこ", u"しろねこ",
 u"みけねこ", u"みけねこ", u"しろねこ", u"くろねこ", u"しろねこ", u"くろねこ", u"くろねこ",
 u"くろねこ", u"みけねこ", u"しろねこ", u"みけねこ", u"みけねこ", u"みけねこ", u"しろねこ"]

  if (neko == u"くろねこ"):
    ...

繰り返しから抜ける

while (条件判定式):
  ...
  ...
  if (条件判定式):
    break
  else:
    ...
  # if … else の終わり
  ...
# while 文の終わり

[ヒント:breakの使い方]

while (...):
  ...
  nyuryoku = input()
  if (nyuryoku == 0):
    break
  else:
    print (u"... それではもう一回やりましょう。\n")
    sleep(2)
  # if ... else文の終わり
  ...
# while文の終わり 

リストの練習問題

ここではリストを使った、今までよりも少し難しい問題を扱います。 この問題を解くことによって、どのようにプログラムを組んだらよいか、 問題を解くためにこのプログラムではどういうことをどういう順番でさせていったらよいか、つまり、アルゴリズム を考える必要性が分かることでしょう。

data = [2,4,27,3,19,26,24,34,10,23,1,11,21,7,8,6,25,35,30,9] 

data = [2,4,27,3,19,26,24,34,10,23,1,11,21,7,8,6,25,35,30,9] 

リストについて---知っておくと良いこと

プログラミング言語Cと異なり、便利なことに、リストの要素は同じ型である必要はありません。 つまり整数や不動小点数、文字列、リストなどが混じっていて良いのです。 また配列の要素数の宣言も限界もありません。つまり、あとで見るように、どんどん要素数を増やすことができます。

>>>  a = [1, 2.3, 'abc', ['a', 'b', 'c']]
>>>  a
[1, 2.3, 'abc', ['a', 'b', 'c']]

>>>  a[0]			# 0番目の要素
1
>>>  a[-1]			# -1は最後の要素の指標
['a', 'b', 'c']
>>>  a[:3]			# 0番目から3－1(つまり2)番目の要素までのリスト
[1, 2.3, 'abc']
>>>  a[4] = 5			# 要素の書き換え:4番目の要素を5にする
>>>  a
[1, 2.3, 'abc', 5]
>>>  a[2:] = [4, 6, 8]		# 2番目以降をリスト[4,6,8]とする
[1, 2.3, 4, 6, 8]

>>>  len(a)
3

>>>  a = [5,1,3,2]		# 変数aの値としてリストをセット
>>>  a.sort()	           	# リストの要素を昇順にソートしたもので書き換える
>>>  a			# 変数aの値の確認
[1, 2, 3, 5]
>>>  a.reverse()		# リストの要素の並びを逆順にしたもので書き換える
>>>  a			# 変数aの値の確認
[5, 3, 2, 1]
>>>  a.append(10)		# リストに1個の要素を追加する（複数の要素の追加は不可）
>>>  a			# 変数aの値の確認
[5, 3, 2, 1, 10]
>>>  a.extend([8,6,4])        # リストに複数の要素を（リストを引数として）追加する
>>>  a			# 変数aの値の確認
[5, 3, 2, 1, 10, 8, 6, 4]

リスト内包記法は次のような形をしており、「計算式の結果」を要素とするリストができます:

  [  計算式  for  変数  in  シーケンス(リスト) ] 

>>>  [ x**2  for  x  in  range(10) ]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

>>>  [ x**2  for  x  in  range(10)  if x%3== 0]
[0, 9, 36, 81]

ここで for の部分は複数かくことができます。それを例で示しましょう:

>>>  [ x**y for x in range(1,8) for y in range(1,4)]
[1, 1, 1, 2, 4, 8, 3, 9, 27, 4, 16, 64, 5, 25, 125, 6, 36, 216, 7, 49, 343]  

このリスト内包記法はとても便利でありよく使われます。それだけに他人が書いたプログラムで目にすることが多いので、慣れておくようにしましょう。

辞書（ディクショナリ）

Cにはないが、RubyやPerlのような他のプログラミング言語で「連想配列」や「ハッシュ」という名前で重宝されているのがこの辞書（ディクショナリ）です。これは一見するとリスト(配列)に似ていますが、リストではインデックスが整数であるのに対し、辞書では文字列や数値がインデックスとして使え、キーと呼ばれています。言い換えれば、リストが数というインデックスにより要素を取り出すのに対し、辞書ではキーによって「連想される」要素を取り出すのです。

辞書は、「キー : 値」という組の集まりを波括弧{ }でくくって表現されます。

>>>  gakusekiList = { 'taro': 3001, 'jiro': 3002, 'hanako' : 3003 }

>>>  gakusekiList['jiro']
3002

>>>  gakusekiList['jiro'] = 3010		# キー'jiro'とペアの値を書き換える
>>>  gakusekiList['jiro']			# キー'jiro'とペアの値の確認
3010
>>>  gakusekiList['naomi'] = 3005        	# 新たなキー'naomi'と値とのペアの登録
>>>  gakusekiList				# gakusekiListの値の確認
{'naomi': 3005, 'hanako': 3003, 'taro': 3001, 'jiro': 3010}

>>>  gakusekiList.keys()
['naomi', 'hanako', 'taro', ', 'jiro']
>>>  gakusekiList.values()
[3005, 3003, 3001, 3010]
>>> 'naomi' in gakusekiList
True
>>>'saburo' in gakusekiList
False

>>>  words = ['there', 'is', 'a', 'book', 'on', 'a', 'desk', 'that', 'belongs', 'to', 'me']
>>>  # ここにプログラムが入る---resultに、それぞれの単語と出現数とが辞書としてはいる
>>>  for x in result:  
          print (x, result[x])

a 2
on 1
to 1
that 1
(以下略)

タプル

>>>  t = 'a', 1, 'b', 2, 3
>>>  print (t)
('a', 1, 'b', 2, 3)
>>>  type(t)
tuple

>>>  t = ('a', 1, 'b', 2, 3)
>>>  print(t)
('a', 1, 'b', 2, 3)

>>>  print(t[0])		# 先頭の要素を表示
'a'
>>>  print(t[1:3])		# 1番目の要素から(3-1)番目の要素までを表示
(1, 'b')
>>>  t[-1] = 'c'		# 要素を変更しようとするとエラーになる
Traceback (most recent call last):
  File "", line 1, in 
TypeError: 'tuple' object does not support item assignment

>>>  t2 = t[:-1]+('c',)	# 最後の要素を除くタプルtに'c'だけからなるタプルを追加
>>>  print(t2)
('a', 1, 'b', 2, 'c')

このタプルには色々な使い方があります。

(1) 数の多重代入
いくつかの変数に一行で同時に値を代入するには、次のようにタプルが使えます:

>>>  x = 10
>>>  a, b, c = x, x**2, x**3
>>>  print( a,b,c)
10 100 1000

>>>  print (x, y)
3 5
>>>  x, y = y, x
>>>  print (x, y)
5 3

(4) 関数の可変長の引数として
これについても関数の項で解説します。

関数

関数とは何か

関数によって、役に立つプログラムに名前をつけ、 その名前を使によりプログラムを呼び出して利用することができるようになります。 これがプログラミングの中での関数の働きの基本です。

関数の定義は次のように、defを用いて書かれます:。

def 関数名():
  本体プログラム

def make_haiku():
  print (u"松島や")
  print (u"ああ　松島や　松島や")
# def文の終わり

関数定義の最初の行をヘッダー、残りの部分を本体(ボディ)といいます。ヘッダーはコロン(:)で終わること、また関数の本体はインデント(段付け)されていることが大事です。インデントのためには(使えれば)タブ、もしくはスペース(2～4個ほど)が使われ、しかも行ごとに同じ個数のタブもしくはスペースを使わないとエラーになりますので注意しましょう。

関数を定義すると、同時に同じ名前の変数ができます。その値は関数オブジェクトといいます。

>>> print (make_haiku)
<function make_haiku at 0x0000000002B1B4A8>
>>> type(make_haiku)
<type 'function'>

>>> make_haiku()
松島や
ああ　松島や　松島や

入力を受け取る関数

プログラムに名前をつけるだけではなく、次のように、入力を取れるようにすることで、関数はもっと強力になります。

def 関数名(引数): 	# 関数の入力に対応する変数のことを仮引数(かりひきすう)と呼びます
  プログラム本体

関数名(引数)     	# 関数の呼び出し部分です。この入力に対応する値のことを
                  # 実引数(じつひきすう)と呼びます。

def make_haiku(word):
  print (word, u"や")
  print (u"ああ", word, u"や", word, u"や")
# def文の終わり

>>> make_haiku(u"中京")
中京 や
ああ　中京 や　中京 や

def aisatsuHiruma(name):
  print (u"こんにちは、", name, u"さん。")
# def 文の終わり

def aisatsuYoru(name):
  print (u"こんばんは、", name, u"さん。")
# def 文の終わり

name = u"太郎"
aisatsuHiruma(name)

name = u"花子"
aisatsuHiruma(name)

name = u"太郎"
aisatsuYoru(name)

name = u"花子"
aisatsuYoru(name)

def aisatsuHiruma(name):
  print (u"こんにちは、",name,u"さん。")
# def 文の終わり

names = [u"名古屋", u"愛知", u"神戸", u"大阪"]

for name in names:
  aisatsuHiruma(name)
# for 文の終わり

複数の値を受け取る関数

関数は二つ以上の引数を受け取ることもできます。 複数の値を受け取る関数を定義する場合、次のように仮引数の変数名をカンマで区切って指定します。

def 関数名(変数1, 変数2, ... , 変数n):
  プログラム

この関数を呼び出して使用するときは、定義部分と同じように、実引数の値（もしくは変数名）をカンマで区切って指定する必要があります。

関数名(値1, 値2, ... , 値n)

一つ目の引数（変数1、値1）を第一引数と呼び、二つ目の引数（変数2、値2）を第二引数と呼びます。 関数が実行されると、第一引数の変数1には値1が代入され、第二引数の変数2には値2が代入されます。

出力を返す関数

以下は、1からn（この場合は100）までの総和を求めるプログラムです (注意: ここはプログラムの練習なので sum関数を使いません)。

n = 100
total = 0
for i in range(1,101):
  total = total + i
# for 
print (u"合計は", total, u"です。")

n=100 と n=1000 と n=10000 の３つの数について和を求めるには、次のように、これを繰り返し使うことでできます。

n = 100
total = 0
for i in range(1,101):
  total = total + i
# for 
print (u"合計は", total, u"です。")

n = 1000
total = 0
for i in range(1,1001):
  total = total + i
# for 
print (u"合計は", total, u"です。")

n = 10000
total = 0
for i in range(1,10001):
  total = total + i
# for 
print (u"合計は", total, u"です。")

このプログラムもやはり、足し算の部分を sowa というような名前の関数にし て使えるようにすればよいのですが、さらに次のように 入力と出力 を取れるようにすると、とても強力になります。

def sowa(num):
  total = 0
  for i in range(1,num+1):
    total = total + i
  # forの終わり 
  return(total)
# defの終わり 

n = 100
print (u"合計は", sowa(n), u"です。")

n = 1000
print (u"合計は", sowa(n), u"です。")

n = 10000
print (u"合計は", sowa(n), u"です。")

入力と出力を取る関数は、次のような形で、作ることができます。 入力に対応する変数のことを引数と呼びます。 出力される値のことを戻り値とか返り値 と呼ぶこともあります。

def 関数名(引数)  # 入力に対応する値を、関数を呼び出したところから受け取ります
  プログラム本体
  return(値)      # 出力に対応する値を、関数を呼び出したところに返します
# def文の終わり

このように関数を定義しておくと、関数名(引数) をプログラムの中に書くだけで、上の sowa(num) のように、簡単に繰り返し使うことができるようになります。 このように、プログラムの中に定義した関数の名前を書いてやると、そこで関数が実行され、結果が値として得られることになります。

def nijiKansu(m):
  kekka = m * m + 3 * m + 2
  return(kekka)
# def文の終わり

n = 1
print (u"入力値が", n, u"のとき、出力値は", nijiKansu(n), u"です。")

n = 2
print (u"入力値が", n, u"のとき、出力値は", nijiKansu(n), u"です。")

n = 3
print (u"入力値が", n, u"のとき、出力値は", nijiKansu(n), u"です。")

n = 5
kekka = 1
for i in range(1,n+1):
  kekka = kekka * i
# for の終わり
print ("答え= ",kekka)

答え= 120
答え= 3628800
答え= 30414093201713378043612608166064768844377641568960512000000000000L

0! = 1
n! = n × (n-1)!	# n ≥ 1 の場合

def factorial(n):			# 階乗計算の関数
   if (n == 0):
      return(1)
   else:
      return(n * factorial(n-1))	# ここで再帰を使っている
# def文の終わり

fibonacci(0) = 1
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1)+fibonacci(n-2)		# n ≥ 2 の場合

a = [3,5,2,7]
print (arraySum(a))
b = [12,24,63,11,29]
print (arraySum(b))
c = [1251,3567,9399,6241]
print (arraySum(c))

17       # a = [3,5,2,7] 
139      # b = [12,24,63,11,29] 
20458    # c = [1251,3567,9399,6241]  

複数の値を返す関数

>>>  quot, rem = divmod(7,3 )		# divmodは商と剰余を返す関数
>>>  print (quote, ' ', rem)
2  1

def divmod(a, b):            		# aとbの商と剰余を求める
   return (a/b, a%b)			# タプルにして返す
# defの終わり

任意の個数の引数をとる関数

任意の個数の引数をとるよう関数を作ることができます。実際、組み込み関数の多く、例えば最大の要素を返すmaxや最小の要素を返すminはそのような関数です。

それには*で始まる変数(パラメタ)を仮引数に書いておきます。 この変数には、実引数を集めたタプルが代入されます。例えば、次で定義される printall関数は任意の個数の値を取り、そのすべてを表示するものです:

def printall(*args):
   print (args)
# def文の終わり

ここで、printallの動きを確認しておきましょう:

>>>  printall(1, 2.0, '3')
(1, 2.0, '3')

>>>  t = (7, 3)			# タプルを作る
>>>  divmod(t)			# divmodの実引数にタプルを与えると...
Traceback (most recent call last):
  File "", line 1, in 
TypeError: divmod() takes exactly 2 arguments (1 given)
>>>  divmod(*t)			# 今度は *t を実引数にする
(2, 1)				# 今度はちゃんと計算できました

>>> sum((1,2,3,4,5))		# sumは引数を1個とりその和を返す---この場合はタプル
15
>>> sum([1,2,3])		# sumは引数を1個とりその和を返す---この場合はリスト
6
>>> sum(1,2,3)			# しかし、sumは任意の個数の引数をとれない
Traceback (most recent call last):
  File "", line 1, in 
TypeError: sum expected at most 2 arguments, got 3
>>>  sumAll([1,2,3]) 
6
>>>  sumAll(1,2,3,4,5)  	# sumall は任意の個数の引数をとれる
15

def sumAll(*args):

関数の中の変数名の有効範囲（スコープ）

変数名には、変数名が意味を持つ有効範囲があります。 特に、関数の内部で使われた変数名はその関数の内部でしか意味を持ちません。 その結果、定義された関数の内部と外部で同じ名前の変数を使用しても、別の変数として扱われる。ため、 同じ変数名が使われていてもお互いの間で値のやりとりは起こりません。 このような変数名の有効範囲のことを、変数のスコープ(scope)とも言います。

具体的な例で見てみましょう。下の例で、関数squareの中の変数answerの値は変化しますが、その変化は関数の外のanswerの値に何の影響も与えません。

def square(num):
  answer = num * num
  print (u"関数の中のanswerの値は", answer)
  return(answer)
# def 文の終わり

answer = 0
print (u"5の二乗を求めます...")
result = square(5)    		    # 関数squareを呼び出して実行し、戻り値を代入する。
print (u"答えは",result, u"でした\n" )
print (u"今のanswerの値は", answer, u"です。"   ) # このanswerは関数squareの中のanswerとは別物

5の二乗を求めます...
関数の中のanswerの値は 25
答えは 25 でした

今のanswerの値は 0 です。

このように、関数の中の変数が外の変数に影響を持たないことで、関数を作る際に、他のところで使われている変数からの余計な影響を気にせずにつくれるようになります。 このことは、特に、大きなプログラムを分担して複数の人で作成するような場合に、重要になります。

このことから、関数の中で得られた結果は、変数を使って受け渡すことはできず、returnを使って、その関数の戻り値として受け渡すことになります。

def square(num):
  answer = num * num
  print (u"関数の中のanswerの値は", answer)
  return(answer)     # 変数answerの値を戻り値として出力する。 
# def文の終わり 

answer = square(5)    		    # 関数squareを呼び出して実行し、戻り値を代入する。
print (u"答えは", answer"です。"   ) # このanswerは関数squareの中のanswerとは別物

関数の中のanswerの値は25
答えは25です。

def shironeko_count(str):
  ...#以下を作る。
  ...
# def の終わり

str = u"しろねこ みけねこ しろねこ くろねこ しろねこ みけねこ くろねこ しろねこ みけねこ"

print ("しろねこは", shironeko_count(str), u"匹います。")

しろねこは4匹います。

>>> s = 'this is a sample sentence'
>>> s.split()
['this', 'is', 'a', 'sample', 'sentence']
>>> s.split('a')
['this is ', ' s', 'mple sentence']

def neko_count(str, type):
  #以下を作る
# def 文の終わり

str = u"しろねこ みけねこ しろねこ くろねこ しろねこ みけねこ くろねこ しろねこ みけねこ"
neko = u"しろねこ"

print (neko, u"は", neko_count(str, neko), u"匹います。")

str = u"しろねこ みけねこ しろねこ くろねこ しろねこ みけねこ くろねこ しろねこ みけねこ"

しろねこは4匹います。
くろねこは2匹います。
みけねこは3匹います。

ary = [3, 51, 2, [22, 7, 4, 8], 3, 5, [12, 13], 98]

228

 [3, 51, 2, [22, 7, 4, 8], 3, 5, [12, 13], 98]

 [3, 51, 2, 22, 7, 4, 8, 3, 5, 12, 13, 98]

>>> ary = [1, 2, 3]			# リスト
>>> ary == type([])			# リストならTrue
True
>>> num = 234	 	      		# 数
>>> ary == type([])			# リストでないならFalse
False

ファイルの入出力(Input-Output)

ここではファイルについて学びます。 ファイルは、現代のコンピュータシステムの基本要素の一つです。 ワードプロセッサーや表計算ソフトのように、どんなアプリケーションプログラムでもファイルを使います。

実際、実用的なプログラムを作る上で、ファイルをプログラムの中から扱かえるようにすることは不可欠です。 ファイルから情報を読み込んで処理したり、その結果をファイルの中に書き込んだりすることが必要になります。

実は、ファイルをプログラムで扱うこと自体はそれほど難しいことではありません。 以下で、プログラムの中からファイルを扱う方法を学びましょう。

ファイルへの書き出し

for x in range(1,4):
  if (x % 2 == 0):
     print (x, 'is an even number')		# evenは偶数
  else:
     print (x, 'is an odd number')		# oddは奇数
# for文の終わり 

1 is an odd number
2 is an even number
3 is an odd number

fout = open("numbers.txt", "w")

特定の名前のファイルを開いて（openして）、そのファイルを扱うための仕掛け（ファイルオブジェクトと呼びます）を、 適当な変数（上の場合はfout）に代入しておきます。 プログラムの中では、そのファイルオブジェクトに対して、書いたり読んだりする操作をしていきます。

openという命令の、ファイル名の次にある"w"は、ファイルを書き出し（Write）の形にするためのものです。 ファイル名も書き出しの"w"も、どちらも文字列で表します。 引用符(シングルクォートでもダブルクォートでもよい)を忘れないように気を付けましょう。 なお、ここでその名前のファイルがある場合には、 その中身が消去されることに注意してください。 なお、中身を消去せずに「追加書き」するものや、 ファイルから読み込みするものは後で述べます。以下がファイルを書き出しとして開くための基本形です：

fout = open("拡張子も含めたファイル名", "w")

fout = open("numbers.txt", "w")
for x in range(1,4):
  if (x % 2 == 0):
     fout.write(str(x)+' is an even number\n')		# evenは偶数
  else:
     fout.write(str(x)+' is an odd number\n')		# oddは奇数
  # if文の終わり 
# for文の終わり 

fout.close()

print命令では、(1)いくつかの値を表示するにはコンマで区切れば良い、(2)数でも文字列でもそのまま書けばその値が表示される、(3)引数の間には自動的にスペースが入る、(4)文字列の表示の後に自動的に改行'\n'が入る、という特徴があります。

それに対し、write命令は(1)一つの文字列だけを引数とすることにも注意しましょう。このため、 str(x)+" is an even number\n"というように、文字列の足し算(文字列の接合)をしていたのです。(2)数を書出すには文字列にしないといけないので、この例ではstr(x)を用いている、(3)文字列同士はスペースがなく接合されるので、print命令にあわせるために、' is an ...'のように先頭にスペースをいれている、(4)最後に改行が入らないので'\n'を文字列の中に含めています。

このような違いに気をつけて fout.writeにより、変数foutの中のファイルオブジェクトに対して文字列を書き出しています。
なお、プログラムの最後にあるfout.closeという命令は、変数foutの中のファイルオブジェクトに対し、ファイルへの書き込みが終わったので、 後始末の処理（ファイルの保存など）をするためものです。 この命令を書き忘れても当面は何も困ったことは起こりませんが（プログラム終了時に自動的にcloseされます）、習慣として書くようにしましょう。 言い換えれば、ファイルは一度開けたら(openしたら)、閉めて(closeして)おいたほうがよいのです。

ファイルへの追加書き

fout = open("numbers.txt", "a")

for x in range(5,8):
  if (x % 2 == 0):
     fout.write(str(x)+' is an even number\n')		# evenは偶数
  else:
     fout.write(str(x)+' is an odd number\n')		# oddは奇数
  # if文の終わり 
# for文の終わり 

fout.close()

書式設定

>>> x = 42
>>> str(x)
'42'					# 文字列になっている

// Cにおける書式設定の例
    printf("%d = %d * %d\n", 10, 5, 2);

# Pythonの書式設定の例
print ("%d = %d * %d\n" % (10, 5, 2))

  書式設定の文字列 % 引数(複数の引数がある場合はタプルにする)

ファイルからの読み込み

今度は、プログラムでファイルの中身を読み込む方法を学びます。
ファイルを読み込むためには、読み込む対象となるファイルが存在している必要があります。 前の課題で作ったnumbers.txtの中身を読み込むことにしましょう。 numbers.txtという名前のファイルが存在し、その中身が次のようなものであることをエディタで確認しておいてください。

1 is an odd number
2 is an even number
3 is an odd number

まず、ファイルの書き出しと同様に、ファイルを扱えるようにしなければなりません。 それには特定の名前のファイルを開いて(open)して、それを扱うための仕掛け（ファイルオブジェクト）を、 適当な変数(以下の場合はfin)に入れておき、それに対して「読む」操作をしていきます。

fin = open("numbers.txt", "r")

ちなみに、ここではファイルから文字列の「読み込み」を行うので、 右辺の括弧の中の二つ目の文字列が読み込み（Read）を指定する"r"になっています。 （書き出しの場合は"w"でした。）

この準備をしておき、readlineメソッドを使うと、ファイルの内容を1行だけ読み込みます。

fin = open("numbers.txt", "r")

line1 = fin.readline()  	# 1行目の読み込み
line2 = fin.readline()  	# 2行目の読み込み
line3 = fin.readline()  	# 3行目の読み込み

fin.close()  			# ファイルを閉じる

print (line1)
print (line2)
print (line3)

1 is an odd number

2 is an even number

3 is an odd number

readlineで読み込まれた1行分の文字列には、改行文字（"\n"）もついていることに注意してください。ですから、それをprintすると、このように改行が2回ずつされるのです。これが嫌な場合は、次に示すstripメソッドにより、文字列の最後の改行コードを切り落としてからprintすればよいでしょう。

>>> x = 'this is a sample sentence.\n'
>>> x.strip()
'this is a sample sentence.'			# 最後の改行コードがなくなっている
>>> print (x)
this is a sample sentence.

# 改行が2回行われた
>>> print (x.strip())
this is a sample sentence.
# 改行は1回だけ行われた

以上のことを行う別なやり方を紹介します。一つ目は read メソッドを使う方法です。 ファイルを「読み込み」で開いておき、readlineではなくreadを使うと、そのファイルの最後まで読み込み、それを一つの文字列として返します。そこで、splitを使います。

fin = open("numbers.txt", "r")			# ファイルを開く
contents = fin.read()				# ファイルの内容を読み込む
for line in contents.split('\n'):		# 改行コードで文字列を分割し、それぞれをlineにセット
   print (line)
# for文の終わり 

fin.close()

もう一つはforを使う方法です。例を見てください。

fin = open("numbers.txt", "r")			# ファイルを開く
for line in fin:				# 一行ずつ読み込みlineにセット
   print (line.strip())				# 改行コードを落としてprintする
# for文の終わり 

fin.close()

読み込み対象のファイルがあるかどうかの確認

ファイルから読み込む場合、そのファイルが実際にある場合は問題ありませんが、ファイルがない場合は。エラーが発生して、プログラムの動きが停止してしまいます。

そこで、対話的にPythonを動かしている場合は、次のようにosモジュールを用いて、実際にファイルがあるかどうか、確かめることを勧めます:

>>> import os				# osモジュールの取込み
>>> os.path.exists('test.dat')		# os.path.existsはファイルパスを引数とするブール関数
False
>>> os.listdir('.')			# os.listdir関数もパスを引数として、そこ('.'で示されている)にあるファイルのリストを返す
[ 'test.txt', 'unnamed.py']

今までに、コマンドプロンプトのウィンドゥで日本語の文字列を表示したり、日本語の文字列を読み込む方法を取り上げました。ここでは、ファイルに対して、日本語の文字列の入出力ができるかどうかを調べてみましょう。まずは入力です:

	
>>> fin = open("jpnText.txt","r")				# jpnText.txtを読み込み対象とする
>>> print( fin.readline() )					# 一行読み込む
このファイルはshift-jisで書かれています

>>> finU = open("jpnTextUnicode.txt","r")			# jpnTextUnicode.txtを読み込み対象とする
>>> print (finU.readline())					# 一行読み込む
# 文字化けする
>>> print (unicode(finU.readline(),"utf-8"))		# 一行読み込む
このファイルはutf-8で書かれています

次は、出力です。次の実行例をみてください:

	
>>> fout = open("test.txt","w")			# test.txtを書き込み用のファイルとして作る
>>> fout.write(u"これはテストです\n")			# 「これはテストです」を書き込む
  File "", line 1, in 
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-7: ordinal not in range(128)
#  UnicodeEncodeError（ユニコード変換エラー）というエラーが発生

>>> import codecs			# codecsモジュールを取り込む
>>> fout=codecs.open("test.txt","w","utf-8")			# test.txtをユニコードで書き込むファイルとして指定
>>> fout.write(u'これはunicodeで書き出します')
# エラーなく正常に書き込まれる

[Shift-JISを指定して書き込む]

>>> import codecs			# codecsモジュールを取り込む
>>> fout=codecs.open("test.txt","w","shift-jis")			# test.txtをshift-jisで書き込むファイルとして指定
>>> fout.write(u'これはshift-jisで書き出します')
# エラーなく正常に書き込まれる

しろねこ みけねこ みけねこ しろねこ しろねこ みけねこ しろねこ しろねこ みけねこ
みけねこ しろねこ みけねこ しろねこ みけねこ みけねこ しろねこ
くろねこ くろねこ しろねこ
みけねこ みけねこ しろねこ くろねこ くろねこ しろねこ みけねこ
みけねこ しろねこ みけねこ くろねこ しろねこ みけねこ
しろねこ みけねこ
しろねこ ばけねこ
...
...省略
...
しろねこ しろねこ くろねこ しろねこ
くろねこ しろねこ
くろねこ しろねこ しろねこ
しろねこ しろねこ しろねこ みけねこ みけねこ しろねこ くろねこ
しろねこ
くろねこ みけねこ みけねこ
しろねこ みけねこ みけねこ しろねこ くろねこ しろねこ くろねこ くろねこ
くろねこ みけねこ しろねこ みけねこ みけねこ みけねこ

>>> fin = open("Nekos.txt","r")			# Nekos.txtファイルを開く
>>> line = fin.readline()				# Nekos.txtファイルから一行読み込む
>>> print (line)				# 表示させる
# 文字化けする場合は...
>>> print (unicode(line,"utf-8"))				# unicodeに変換して表示させる
しろねこ みけねこ みけねこ しろねこ しろねこ みけねこ しろねこ しろねこ みけねこ

課題6-7

[ヒント1]

#1行目
"しろねこ みけねこ みけねこ しろねこ しろねこ みけねこ しろねこ しろねこ みけねこ"

#2行目
"みけねこ しろねこ みけねこ しろねこ みけねこ みけねこ しろねこ"

#3行目
...

[ヒント2]

合計は最初は0匹。
while ... :  #ファイルから1行ずつ読み込む。

  「とらねこ」の数を数える。

  合計に「とらねこ」の数を加算する。
# while 

  line = 1行分の文字列
  ねこの文字列を分割する。
  「とらねこ」は最初0匹。
  for ... : #ねこを1匹ずつチェックする。（while文を使ってもよい。）
    「とらねこ」なら1匹加算する。
  # forの終わり

合計は最初は0匹。
for ...:  #ファイルから1行ずつ読み込む。

  line = 1行分の文字列
  ねこの文字列を分割する。
  「とらねこ」は最初0匹。
  for ...:  #ねこを1匹ずつチェックする。（while文を使ってもよい。）
    「とらねこ」なら1加算する。
  # forの終わり 

  合計に「とらねこ」の数を加算する。
# forの終わり 

課題6-8

しろねこ の出現数は 162
くろねこ の出現数は 129
みけねこ の出現数は 141
とらねこ の出現数は 13
... (以下略)

エラーと例外

Pythonでは次のようにtryと exceptを用いて例外の処理を扱えます:

try:
   エラーを起こしそうなプログラム
except:
  エラーが起こったときの処理

このようにtry文で例外を扱うことを「例外をキャッチする(捕らえる)」といいます。例えば、次はファイルの処理において何らかのエラーが起きた時に、something went wrong.(なにかおかしい)と表示するコードの例です

try:
	fin = open('bad_file.txt')
	for lines in fin:
		print (line)
	fin.close()
except:
	print ('Something went wrong.')
# 例外処理のおわり

クラス

Cでは構造体によって、構造をもつオブジェクト(言い換えれば、いくつかのパーツから構成されるモノ。例えば、計算機分野で用いられるセル、現実のオブジェクトでいえばコンピュータとか自動車のようなもの)を定義し、使うことができました。しかしそのオブジェクトに固有の関数（セルに対してはセルの値を取り出す、値を書き換える、次のセルを指すポインタを取り出す。自動車でいえば、起動する、停止する、左回転する、など）というものはないため、どの関数がそのオブジェクトに固有かどうかは、マニュアル(コメント)を見る以外に(それ用のヘッダファイルなどが整理されていない限り)方法はありませんでした。それに対し、クラスは、構造体に加えて固有の関数をセットで定義できるようにしたものとみなせます。ここでクラス固有の関数を普通の関数と区別するため「メソッド」と呼びます。

クラスを使うには、そのクラスがどのような構造を持つか、どのようなメソッドがあるかを「定義」することと、実際にその「インスタンス」オブジェクトを作って、インスタンスに値を与えたり、メソッドを適用したりすることの２つがあります。クラス定義とインスタンスとの関係は、いわば鯛焼きの金型(形を決める)と、金型に材料を加えて焼いてできる実際に食べられる鯛焼きの関係に当たります。金型一つから、材料を与えることでいろいろな鯛焼きができるのです。

クラスの定義のもっとも簡単な形を示します：

class  クラス名:
  文1 ; ... 文n
  def __init__(self, x1, ..., xk):
    文i1
     ... 
    文1m
  def メソッド2(self, y1,..., ym):
    文21
     ... 
    文2m
  ...

class Complex: 				# 複素数クラス
      def __init__(self, real, imag):
        self.r = real
        self.i = imag
# class文の終わり

>>> x = Complex(2.0, 3.0)

>>> x
<__main__.Complex instance at 0x0000000003E4A7C8>
>>> type(x)
instance
>>> x.r, x.i
(2.0, 3.0)

class Complex: 				# 複素数クラス

  def __init__(self, real, imag):
     self.r = real
     self.i = imag
  def add(self, comp):
     real = self.r + comp.r
     img = self.i + comp.i
     return Complex(real,imag)
  def mult(self, comp):
     real = self.r * comp.r + self.i * comp.i
     imag = self.r * comp.i + self.i * comp.r
     return Complex(real,imag)
# class文の終わり# class文の終わり

>>> x = Complex(2.0,3.0)
>>> y = Complex(-1.0, -1.0)
>>> z = x.add(y)
>>> z.r, z.i
(1.0, 2.0)
>>> z=x.mult(y)
>>> z.r, z.i
(1.0, -5.0)