プログラミング演習 on Miura Computer Club

レッスン127

Thu, 17 Sep 2026 09:00:00 +0900

Python演習ドリル200 基礎練習61〜70

Pythonプログラムを学び始めた方向けの演習ドリルです。

今回は、基礎練習の61〜70です。

jupyterとjupyter notebook

本演習ではjupyter notebookを使用します。インストールされているか確認してください。インストールされていない場合、jupyterとjupyter notebookのインストール方法については、レッスン33を参照してください。

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

リスト（配列）つづき
- スライス
  
  スライスはレッスン125の文字列で学んだ文字列のスライスとほぼ同じですが、復習として説明します。
  
  スライスでは選択範囲の開始位置startと終了位置stopをリスト[start:stop]のように書きます。すると、start <= x < stopの範囲が選択されます。 start番目の値は含まれますが、stop番目の値は含まれないことに注意してください。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[2:5])
>> [20, 30, 40]
```
  スライスで指定する位置（インデックス）は以下のとおりです。
```
 +---+---+---+---+---+---+---+
 | 0 | 10| 20| 30| 40| 50| 60|
 +---+---+---+---+---+---+---+
 0   1   2   3   4   5   6   7
-7  -6  -5  -4  -3  -2  -1
```
  開始位置startを省略すると先頭（最初）から、終了位置stopを省略すると末尾（最後）までが選択されます。両方とも省略するとすべての要素が選択されます。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[:3])
>> [0, 10, 20]

print(l[3:])
>> [30, 40, 50, 60]

print(l[:])
>> [0, 10, 20, 30, 40, 50, 60]
```
  - 範囲外を指定した場合
    
    要素数を超える位置を指定してもエラーにならず無視されます。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[2:10])
>> [20, 30, 40, 50, 60]
```
  - 空のリストが返る場合
    
    どの要素も選択されないstartとstopを指定してもエラーにはならず、空のリストが返ります。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[5:2])
>> []

print(l[2:2])
>> []

print(l[10:20])
>> []
```
  - 増分stepを指定
    
    startとstopに加えて、増分stepも指定可能です。 [start:stop:step]のように書きます。
    
    例えば、stepを2とした場合、奇数個目または偶数個目の要素のみを取得できます。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[::2])
>> [0, 20, 40, 60]

print(l[1::2])
>> [10, 30, 50]
```
    その他の例です。
```
l = [0, 10, 20, 30, 40, 50, 60]
print(l[::3])
>> [0, 30, 60]

print(l[2:5:2])
>> [20, 40]
```
    なお、stepを省略した場合はstep=1となります。
  - マイナスの値で後ろから指定
    - 開始位置startと終了位置stopをマイナスで指定
      
      開始位置startと終了位置stopを負の値で指定すると、末尾からの位置になります。先ほど説明したスライスで指定する位置（インデックス）の表を参照してください。
      l = [0, 10, 20, 30, 40, 50, 60] print(l[3:-1]) >> [30, 40, 50] print(l[-2:]) >> [50, 60] print(l[-5:-2]) >> [20, 30, 40]
    - 増分stepをマイナスで指定
      
      増分stepを負の値で指定すると、後ろから逆順で要素を取得します。
      
      startから逆順に値を取得していくため、startのほうがstopより後ろの位置を示していないと空のリストを返すので注意してください。
      l = [0, 10, 20, 30, 40, 50, 60] print(l[5:2:-1]) >> [50, 40, 30] print(l[2:5:-1]) >> []
      その他の例です。
      l = [0, 10, 20, 30, 40, 50, 60] print(l[-2:-5:-1]) >> [50, 40, 30] print(l[-2:2:-1]) >> [50, 40, 30] print(l[5:2:-2]) >> [50, 30]
      stepが負の値の場合、startを省略すると末尾から、stopを省略すると先頭までが選択されます。両方とも省略するとすべての要素が選択されます。
      
      startとstopを省略し、stepを-1とすることでもとのリストの順番を逆転したリストを取得することができます。
      l = [0, 10, 20, 30, 40, 50, 60] print(l[:3:-1]) >> [60, 50, 40] print(l[3::-1]) >> [30, 20, 10, 0] print(l[::-1]) >> [60, 50, 40, 30, 20, 10, 0]
- indexメソッド
  
  リスト.index(要素)のようにindexメソッドを実行すると、先頭から最初に要素に一致した位置（インデックス）を返します。存在しない要素を指定するとエラーになります。
```
nums = [1, 1, 2, 3, 3]
print(nums.index(1))
>> 0

print(nums.index(2))
>> 2

print(nums.index(3))
>> 3

print(nums.index(0))
>> ValueError: 0 is not in list
```
- 累算代入演算子
  
  +=演算子を使用すると、リストにリストを追加します。 リスト1 += リスト2 でリスト1の要素の後ろにリスト2の要素がコピーされて追加されます。なお、リスト2の値は変わりません。
```
l1 = ['a', 'b', 'c']
l2 = ['d', 'e', 'f']
l1 += l2
print(l1)
>> ['a', 'b', 'c', 'd', 'e', 'f']

print(l2)
>> ['d', 'e', 'f']
```
  l1 = l1 + l2のように書いても同じ結果が得られます。
  
  追加される要素は元のリストからコピーされるので、要素がリストや辞書などの場合、追加された要素の内容を変更すると元のリストの要素の内容も変更されてしまうので注意が必要です。（逆に、元のリストの要素の内容を変更すると、追加された要素の内容も変更されます）。
- insertメソッド
  
  リスト.insert(インデックス、要素)のようにinsertメソッドを実行すると、リストのインデックスの位置に要素を挿入します。
  
  インデックスの先頭は0、負の値の場合はスライス同様で、-1が末尾（最後）の1つ前になります。
```
l = ['a', 'b', 'c']
l.insert(1, 100)
print(l)
>> ['a', 100, 'b', 'c']

l.insert(0, 200)
print(l)
>> [200, 'a', 100, 'b', 'c']

l.insert(-1, 300)
print(l)
>> [200, 'a', 100, 'b', 300, 'c']

l.insert(-2, 400)
print(l)
>> [200, 'a', 100, 'b', 400, 300, 'c']		
```
  なお、インデックスに範囲外の値を指定してもエラーにはならず、先頭より前の値を指定すると先頭に、末尾より後の値を指定すると末尾に値が挿入されます。
```
l = ['a', 'b', 'c']
l.insert(100, 100)
print(l)
>> ['a', 'b', 'c', 100]

l.insert(-100, 200)
print(l)
>> [200, 'a', 'b', 'c', 100]	
```
- removeメソッド
  
  リスト.remove(要素)のようにremoveメソッドを実行すると、指定した要素と同じ値の要素を検索し、最初に検索された要素を削除します。指定した要素と一致する要素がリストに複数含まれる場合は、一番前にある要素1つだけ削除されます。
  
  なお、指定した要素と同じ値の要素が存在しない場合は、エラーになります。
```
l = ['Alice', 'Bob', 'Charlie', 'Bob', 'Dave']
l.remove('Alice')
print(l)
>> ['Bob', 'Charlie', 'Bob', 'Dave']

l.remove('Bob')
print(l)
>> ['Charlie', 'Bob', 'Dave']

l.remove('Eric')
>> ValueError: lis.remove(x): x not in list
```
- popメソッド
  
  リスト.pop(インデックス)のようにpopメソッドを実行すると、指定したインデックスの位置の要素を削除し、その値を取得します。インデックスの先頭（最初）は0、負の値を指定するとスライス同様末尾からの位置を指定できます。末尾（最後）は-1です。
  
  引数を省略してリスト.pop()とすると、末尾（最後）の要素を削除します。
  
  なお、存在しない位置を指定するとエラーになります。
```
l = [0, 10, 20, 30, 40, 50]
popped_item = l.pop(0)
print(popped_item, l)
>> 0 [10, 20, 30, 40, 50]

popped_item = l.pop(3)
print(popped_item, l)
>> 40 [10, 20, 30, 50]

popped_item = l.pop(-2)
print(popped_item, l)
>> 30 [10, 20, 50]

popped_item = l.pop(100)
>> IndexError: pop index out of range
```
- del文
  
  del文を使い、インデックス・スライスで位置・範囲を指定してリストの要素を削除することができます。
  
  del リスト[インデックス]のように削除したい要素をインデックスで指定します。インデックスは先頭（最初）は0、負の値は末尾（最後）が-1になります。
```
l = [0, 10, 20, 30, 40, 50]
del l[0]
print(l)
>> [10, 20, 30, 40, 50]

del l[3]
print(l)
>> [10, 20, 30, 50]

del l[-1]
print(l)
>> [10, 20, 30]

del l[-2]
print(l)
>> [10, 30]
```
  del リスト[スライス]のようにスライスを使用すると、選択した範囲の要素を一括で削除できます。全範囲を指定してすべての要素を削除することも可能ですし、増分stepを指定して、飛び飛びの複数の要素を一括で削除することもできます。スライスの使い方については、すでに説明済みのスライスの項目を参照してください。
```
l = [0, 10, 20, 30, 40, 50]
del l[2:5]
print(l)
>> [0, 10, 50]

l = [0, 10, 20, 30, 40, 50]
del l[:3]
print(l)
>> [30, 40, 50]

l = [0, 10, 20, 30, 40, 50]
del l[-2:]
print(l)
>> [0, 10, 20, 30]


l = [0, 10, 20, 30, 40, 50]
del l[:]
print(l)
>> []

l = [0, 10, 20, 30, 40, 50]
del l[::2]
print(l)
>> [10, 30, 50]
```
- 内包表記
  
  リスト内包表記は以下のように書きます。
```
[式 for 任意の変数名 in イテラブルオブジェクト]
```
  リストやタプル、rangeなどのイテラブルオブジェクトの各要素を任意の変数名で取り出し、式で評価し、その結果を要素とする新たなリストを作成します。
  
  例えば、rangeの要素（連番）を取り出し式で2乗すると以下のようなリストを作成することができます。
```
square = [i**2 for i in range(5)]
print(square)
>> [0, 1, 4, 9, 16]
```
  内包表記を使わずに同じことをするには、以下のような処理が必要になります。
```
square = []
for i in range(5):
	squares.append(i**2)

print(square)
>> [0, 1, 4, 9, 16]		
```
  - ifで条件分岐した内包表記
    
    ifで条件分岐することも可能です。以下のようにifを後に付けて書きます。
```
[式 for 任意の変数名 in イテラブルオブジェクト if 条件式]
```
    条件式がTrueとなるイテラブルオブジェクトの要素のみ式で評価され、その結果が要素となる新たなリストが返されます。 Falseとなる要素は無視されます。
    
    条件式の中でも任意の変数名を使用することができます。
    
    例えば、rangeの要素（連番）から奇数のみを取り出してリストを作成してみます。
```
odds = [i for i in range(10) if i % 2 == 1]
print(odds)
>> [1, 3, 5, 7, 9]
```
    内包表記を使わずに同じことをするには、以下のような処理が必要になります。
```
odds = []
for i in range(10):
	if i % 2 == 1:
		odds.append(i)

print(odds)
>> [1, 3, 5, 7, 9]		
```
  - 三項演算子(if else)との組み合わせ
    
    条件分岐では、条件を満たす要素のみが処理され、条件を満たさない要素は除外されます。
    
    if else のように条件によって処理を切り替えたい場合は以下の三項演算子を使用します。
```
Trueのときの値 if 条件式 else Falseのときの値
```
    これを以下のように内包表記の式の部分に使用します。
```
[Trueのときの値 if 条件式 else Falseのときの値 for 任意の変数名 in イテラブルオブジェクト]
```
    以下の例では、rangeの要素（連番）を取り出し、奇数は'odd'、偶数は'even'に置き換えます。
```
odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(even_odd)
>> ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']
```
    内包表記を使わずに同じことをするには、以下のような処理が必要になります。
```
odd_even = []
for i in range(10):
	if i % 2 == 1:
		odd_even.append('odd')
	else:
		odd_even.append('even')

print(even_odd)
>> ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']
```
    Trueのときの値、Falseのときの値に任意の変数名を使った式を記述することもできます。
  - zip関数、enumerate関数との組み合わせ
    
    今後のレッスンで説明する複数のイテラブルをまとめるzip関数や、以前のレッスンで説明したインデックスと値をペアで返すenumerate()などと組み合わせることも可能です。
    
    zip関数の例です。
```
l1 = ['a', 'b', 'c']
l2 = [10, 20, 30]

l = [(s1, s2) for s1, s2 in zip(l1, l2)]
print(l)
>> [('a', 10), ('b', 20), ('c', 30)]

enumerate関数の例です。

```python
    l1 = ['a', 'b', 'c']
    l = [(i, s) for i, s in enumerate(l1)]
    print(l)
    >> [(0, 'a'), (1, 'b'), (2, 'c')]
```
さらにこれらにifを付けることもできます。
- ネスト（階層化）した内包表記（多重ループ）
  
  forループの中にforループがある多重ループのように、内包表記も同様の多重ループが使えます。
```
  [式　for 変数名1 in イテラブルオブジェクト1
  	for 変数名2 in イテラブルオブジェクト2
  		for 変数名3 in イテラブルオブジェクト3...]
```
  便宜上、改行とインデントを加えているが、1行で続けて書いても構いません。
  
  range関数を使って二重ループで内包表記を行う例です。
```
  l = [(x, -y) for y in range(3) for x in range(3)]
  print(l)
  >> [(0, 0), (1, 0), (2, 0), (0, -1), (1, -1), (2, -1), (0, -2), (1, -2), (2, -2)]
```
- 多次元配列の作成
  
  配列の*演算子のところで説明したように、多次元配列を*演算子で作成しようとすると意図しない結果になります。
```
  l = [[0] * 3] * 3
  print(l)
  >> [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
  
  l[0][0] = 1
  print(l)
  >> [[1, 0, 0], [1, 0, 0], [1, 0, 0]]
```
  上記のように配列の中に同じ配列のコピーが3個できるので独立の2次元配列にはなりません。
  
  このような場合、内包表記を使うことでこの問題を解決できます。
```
  l = [[0] * 3 for _ in range(3)]
  print(l)
  >> [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
  
  l[0][0] = 1
  print(l)
  >> [[1, 0, 0], [0, 0, 0], [0, 0, 0]]
```
  このように、内包表記を使うと簡単に独立の多次元配列を作成することができます。

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習61〜70.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習61〜70というタイトルの演習問題が表示されます。

課題61から課題70までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

まとめ

今回はPython演習として、リストの続きを行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。

レッスン126

Thu, 17 Sep 2026 08:00:00 +0900

Python演習ドリル200 基礎練習51〜60

Pythonプログラムを学び始めた方向けの演習ドリルです。

今回は、基礎練習の51〜60です。

jupyterとjupyter notebook

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

書式化

Pythonでprint関数の書式を指定するには書式化演算子（%）、formatメソッド、f文字列の3種類の方法があります。 f文字列についてはレッスン125ですでに説明しているので、今回は書式化演算子（%）とformatメソッドについて説明します。

書式化演算子（%）

書式化演算子で書式を指定して新しい文字列を作成するには次のような形式になります。
```
変換指定子を含む文字列 % 値
変換指定子を含む文字列 % (値1, 値2, ...)
```
まず、変換指定子を含む文字列についてです。例えば、次のような文字列を例に考えてみます。
```
"名前はxxです。年齢はyy歳です。"
```
この文字列の名前の部分(xx)と年齢の部分(yy)に書式化を行った値を挿入して新しい文字列を作成したい場合、以下のように、このxxとyyの部分にどのように値を書式化するかを表す%で始まる変換指定子を指定します。
```
"名前は%-8sです。年齢は%03d歳です。"
```
次に、書式化を行う値を指定します。今回変換指定子を文字列の中に2つ記述しましたので、変換する値も2つ記述する必要があります。値は文字列のあとに%を記述したあと、(値1, 値2)のようにタプルオブジェクト（書き換えのできない配列）として指定します。タプルには変換指定子が記述された順番通りに要素として値を追加します。
```
"名前は%-8sです。年齢は%03d歳です。" % ("Suzuki", 18)
```
なお、変換指定子が1つの場合、値は1つとなり、この場合はタプルではなく値を直接記述することができます。
```
"名前は%-8sです。" % "Suzuki"
```
- 変換指定子の指定方法
  
  変換指定子は次のように記載します。
```
% （マップキー） 変換フラグ 最小フィールド幅 精度 変換型
```
  変換指定子は%から始まり、(1)マップキー、(2)変換フラグ、(3)最小フィールド幅、(4)精度、(5)変換型、をそれぞれ指定します。この中で必須な項目は(6)変換型だけで、(1)から(4)はオプションです。
  - 変換型
    
    必須項目である変換型は次の値が用意されています。
```
"d" 符号付き10進整数
"i" 符号付き10進整数
"o" 符号付き8進数
"x" 符号付き16進数（小文字）
"X" 符号付き16進数（大文字）
"e" 指数表記の浮動小数点数（小文字）
"E" 指数表記の浮動小数点数（大文字）
"f" 10進浮動小数点数
"F" 10進浮動小数点数
"g" 浮動小数点数。指数部が-4以上または精度以下の場合は小文字指数表示、それ以外の場合は10進表記。
"G" 浮動小数点数。指数部が-4以上または精度以下の場合は大文字指数表示、それ以外の場合は10進表記。
"c" 文字一文字（整数または一文字からなる文字列）
"r" 文字列（Pythonオブジェクトをrepr()で変換）
"s" 文字列（Pythonオブジェクトをstr()で変換）
"a" 文字列（Pythonオブジェクトをascii()で変換）
"%" 引数を変換せず、返される文字列中では文字'%'になります
```
  - マップキー
    
    値を指定する時にタプルではなく辞書を使用する場合に使います。マップキーは()で囲って指定します。
    
    以下の例では、2つの変換指定子にそれぞれ(decnum)と(hexnum)というマップキーを指定しています。そして値を指定する時に、タプルではなく辞書を使い、辞書の要素毎にキーには変換指定子に指定したマップキーを指定し、値には変換指定子に渡す値を指定します。
```
print("10進数=%(decnum)d, 16進数=%(hexnum)x" % {"hexnum":20, "decnum":20})
>> 10進数=20, 16進数=14
```
    辞書の要素はどのような順番で記述されても構いません。
  - 変換フラグ
    
    変換フラグには次の値が用意されています。
```
"#" 値の変換に"別の形式"を使う
"0" 数値型に対してゼロパディング（0で埋める）を行う
"-" 変換された値を左寄せする
" " 符号付きの変換で正の値の場合、前に一つスペースをあける(-とそろえるため）
"+" 変換の先頭に符号文字（'+'または'-'）を付ける
```
    変換フラグに"#“を指定した場合、変換型に"o"を指定すると8進数を表す接頭辞（0o）が、 “x"を指定すると16進数を表す接頭辞（0x）が、“X"を指定すると16進数を表す接頭辞（0X）が、それぞれ最初の数字の前に挿入されます。
```
print("数値1=%x, 数値2=%#x" % (30, 30)")
>> 数値1=1e, 数値2=0x1e
```
    変換フラグに"0"を指定した場合、この後説明する最小フィールドよりも数値の桁数が小さかった場合に0で埋められます。この変換フラグを指定していない場合はスペースで埋められます。
```
print("数値1=%5d, 数値2=%05d" % (30, 30)")
>> 数値1=   30, 数値2=00030
```
    変換フラグに”-“を指定した場合、この後説明する最小フィールドよりも数値の桁数が小さかった場合に左寄せで表示します。この変換フラグを指定していない場合は右寄せで表示します。下記の例では左寄せなのがわかりやすいように数値の前後に[]を付けています。
```
print("数値1=[%5d], 数値2=[%-5d]" % (30, 30)")
>> 数値1=[   30], 数値2=[30   ]
```
    変換フラグに” “を指定した場合、正の値の場合だけ数値の前にスペースを1文字入れ、負の値と桁数がそろうようにします。
```
print("数値1=%d, 数値2=%d, 数値3=% d, 数値4=% d" % (30, -30, 30, -30)")
>> 数値1=30, 数値2=-30, 数値3= 30, 数値4=-30
```
    変換フラグに”+“を指定した場合、数値の先頭に”+“または”-“を付けます
```
print("数値1=%+5d, 数値2=%+5d" % (30, -30)")
>> 数値1=+30, 数値2=-30
```
  - 最小フィールド幅
    
    最小フィールド幅は、少なくとも確保される桁数を指定します。例えば数値や文字列が3桁で、最小フィールド幅が5だった場合には、5桁の場所に3桁の数値や文字列を表示します。変換フラグを指定しないと、右寄せで表示され、空いてる部分にスペースが表示されますが、変換フラグを指定することで、左寄せにしたり、0で埋めたりすることができます。また、最小フィールドより値が大きい桁数だった場合は、最小フィールドの値は無視され、そのまま表示されます。
```
print("数値1=%d, 数値2=%4d, 数値3=%4d" % (30, 30, 72536))
>> 数値1=30, 数値2=  30, 数値3=72536
```
    なお、最小フィールド幅に”*“を指定した場合、最小フィールド幅を値の方で指定することができます。この場合、最初に最小フィールド値を指定してから実際の値を指定します。
```
print("数値1=%d, 数値2=%*d" % (18, 5, 42)")
>> 数値1=18, 数値2=   42
```
    変換指定子は2つですが、値の方は3つ指定しています。最初の値(18)は、最初の変換指定子(%d)で変換する値。 2つ目の値(5)は2つ目の変換指定子(%*d)の最小フィールド幅。 3つ目の値(42)は 2つ目の変換指定子(%*d)で変換する値です。最小フィールドの方から先に値を指定する点に注意してください。
  - 精度
    
    最後は精度です。小数部分の精度（桁数）を指定します。何も指定しないと6桁になります。指定する場合にはドット（.）のあとに桁数を指定してください。
```
print("数値1=%f, 数値2=%.3f" % (1/3, 1/3))
>> 数値1=0.333333, 数値2=0.333
```
    なお、精度に”*“を定した場合、精度を値の方で指定することができます。この場合、最初に精度を指定してから実際の値を指定します。
```
print("数値1=%f, 数値2=%.*f" % (1/3, 3, 1/3))
>> 数値1=0.333333, 数値2=0.333
```
    変換指定子は2つですが、値の方は3つ指定しています。最初の値(1/3)は、最初の変換指定子(%f)で変換する値。 2つ目の値(3)は2つ目の変換指定子(%*f)の精度。 3つ目の値(1/3)は2つ目の変換指定子(%*f)で変換する値です。精度の方から先に値を指定する点に注意してください。

formatメソッド

formatメソッドで書式を指定して新しい文字列を作成するには次のような形式になります。

変換指定子{}を含む文字列.format(値1, 値2, ...)

まず、変換指定子{}を含む文字列についてです。例えば、次のような文字列を例に考えてみます。

"名前はxxです。年齢はyy歳です。"

この文字列の名前の部分(xx)と年齢の部分(yy)に書式化を行った値を挿入して新しい文字列を作成したい場合、以下のように、このxxとyyの部分にどのように値を書式化するかを表す{}で変換指定子を指定します。

"名前は{0:<8s}です。年齢は{1:03d}歳です。"

次に、書式化を行う値を指定します。今回変換指定子を文字列の中に2つ記述しましたので、変換する値も2つ記述する必要があります。値は文字列のあとに.format()メソッドを指定し、(値1, 値2)のようにメソッドの引数として指定します。引数には変換指定子で指定した0から始まるインデックスの順にしたがって値を指定します。

"名前は{0:>8s}です。年齢は{1:03d}歳です。".format("Suzuki", 18)

なお、変換指定子と引数が左から順に1対1になっている場合は、以下のようにインデックス番号を省略できます。

"名前は{:>8s}です。年齢は{:03d}歳です。".format("Suzuki", 18)

変換指定子の指定方法

変換指定子は次のように記載します。

{インデックス番号:文字寄せ 最小幅 カンマ 精度 型}

型（タイプ）の指定

一般に用いられる型

記号	型（タイプ）	備考
`c`	文字列	省略時は文字列なので、通常は省略する
`d`	整数（10進数）	2進数は`b`、16進数は`x`（小文字）または`X`（大文字）
`e`または`E`	浮動小数点（指数表記）	大文字（`E`）の場合は指数表記がeではなくE
`f`または`F`	浮動小数点（小数点表記）	大文字（`F`)の場合はnanがNAN、infがINF

精度（小数点以下の桁数）

「小数点以下?桁」を指定するには、{:.?f}のようにピリオド.の後に整数で桁数を指定します。
```
print("{:.1f}, {:.2f}, {:.5f}".format(0.01, 0.01, 0.01))
>> 0.0, 0.01, 0.01000
```
指数表記の場合は以下のようにeまたはEを用います。
```
print("{:.1e}, {:.2e}, {:.5e}, {:.5E}".format(0.01, 0.01, 0.01, 0.01))
>> 1.0e-02, 1.00e-02, 1.00000e-02 1.00000E-02
```
また、この精度指定を文字列型に使用すると、文字列を最大何文字使用するかを指定できます。
```
print("{:.2}, {:.3}, {:.7}".format("abcde", "abcde", "abcde"))
>> ab, abc, abcde
```
なお、当然ですが精度は整数型（d, b, o, x, X）には使用できません
カンマ（千の位ごと）

千の位ごとに「カンマ（,）」を入れたい場合は、以下のように,を指定します。
```
print("{0:,}".format(1234567))
>> 1,234,567
```
小数点以下の精度指定と併記する場合は、以下のように,は左に入力します。
```
print("{0:,.2f}".format(1234567))
>> 1,234,567.00
```
最小幅

最小幅は、桁数指定の前で指定します。最小幅とは「これ以上狭くならない幅」のことであり、列の幅を揃えたい場合などにるよう出来ます。最小幅に足りない場合、後で説明するパディングを指定しなければスペースで埋められます。

以下の浮動小数点型の例で、{:3.5f}では幅に3を指定していますが、データの0.01は.5fで小数点以下5桁まで表示されるので0.01000と幅は7になります。

このようにデータの表示が最小幅に足りている（最小幅以上）の場合は、データの部分は削られることなくそのまま表示されます。一方、{:10.5f}で最小幅を10に指定して0.01を表示するとデータ幅は7で3足りないので、左側を3つのスペースで埋めます。
```
print("'{:3.5f}', '{:10.5f}'".format(0.01, 0.01))
>> '0.01000', '   0.01000'
```
文字列型の場合も同様に指定した最小幅に足りない場合は、スペースで埋められます。ただし、文字列型では右側を空白で埋めます。
```
print("'{:2}', '{:10}'".format("abcde", "abcde"))
>> 'abcde', 'abcde     '
```
整数型の場合は、浮動小数点型と同様に、最小幅に足りない場合は左側をスペースで埋めます。
```
print("'{:2d}', '{:10d}'".format(100, 100))
>> '100', '       100'
```
文字寄せ（パディング）

何も指定しないと数値は右寄せ、文字は左寄せです。文字列を右詰めしたい場合は、頭に>を付けます。
```
print("'{:>20}'".format("abcde"))
>> '               abcde'
```
スペースの部分を任意の文字で埋めたい場合は、>の前に文字（1文字）を指定します。
```
print("'{:*>20}'".format("abcde"))
>> '***************abcde'
```
数値の空白部分をゼロ(0)で埋めたい（ゼロパディング）場合には、最小幅の頭に0を付けるだけでできます。
```
print("{:02d}, {:010d}".format(100, 100))
>> 100, 0000000100
```
インデックス番号

どの引数を表示するかは0から始まるインデックス番号で指定します。インデックス番号は昇順に指定する必要はありません。また同じインデックス番号を繰り返し使用しても構いません。
```
print("xyz={1}, abc={0}, abcxyz={0}{1}".format("abc", "xyz"))
>> xyz=xyz, abc=abc, abcxyz=abcxyz
```
- インデックス番号の代わりにキーワードを指定する
  
  インデックス番号の代わりに キーワードを指定することもできます。
  
  以下のように文字列の中に{キーワード}を埋め込み、format()メソッドの引数に、キーワード=値を入力すると{キーワード}の部分を指定した値に置換してくれます。
```
print("私の名前は{name}、年齢は{age:d}歳です。".format(name="小野寺健", age=66))
>> 私の名前は小野寺健、年齢は66歳です。
```
- リストやタプルを埋め込む
  
  引数にリスト、タプル、辞書などを設定し、{}の中のインデックスに[添字]を付けることで、リストやタプルなどの要素を埋め込むことができます。
```
"{0[添字]}, {0[添字]}, {1[添字]}, {1[添字]}".format(リスト1, タプル1)
```
  リストを例に取ると、以下のような使い方ができます。
```
apple, orange = 50, 100
total = apple + orange
price = [apple, orange, total]

print("りんご：{0[0]}円 みかん{0[1]}円 合計：{0[2]}円".format(price))
>> りんご：50円 みかん：100円 合計：150円
```
  先ほどのキーワードと組み合わせることも可能です。
```
apple, orange = 50, 100
total = apple + orange
price = [apple, orange, total]

print("りんご：{price[0]}円 みかん{price[1]}円 合計：{price[2]}円".format(price=price))
>> りんご：50円 みかん：100円 合計：150円
```

isprintableメソッド

print関数を実行した際に文字列がすべて出力できる場合はTrue、出力できない文字が含まれている場合はFalseを返します。
```
"I am studying python".isprintable() # True
"I am\n studying\a python" # False
```

リスト（配列）

複数の要素を配列としてまとめたものをPythonでは**リスト（list）**と呼びます。
- リスト表示演算子（[]）
  
  以下のように、[]の中に要素を,で区切って入れることでリストを作成することができます。リストをprint関数で表示すると[要素1, 要素2, ...]のように表示されます。
```
fruits = ["apple", "banana", "melon"]
print(fruits)
>> ['apple', 'banana', 'melon']
```
  作成したリストの各要素は0から始まるインデックス番号を使いリスト[インデックス番号]で取り出したり書き換えたりすることができます。
```
fruits = ["apple", "banana", "melon"]
print(fruits[0], fruits[1], fruits[2])
>> apple banana melon
fruits[0] = "orange"
print(fruits)
>> ['orange', 'banana', 'melon']
```
  なお、配列の要素数以上のインデックス番号を指定するとエラーになります。
  
  num = []のように空のリストを作成することもできます。 空のリストには後からappendメソッドなどを使用して要素を追加することができます。
  
  リストの要素には、数値、文字列を始めとして様々な型の値を入れることができます。 CやJavaなどの言語の配列とは異なり、Pythonのリストでは要素の型は要素ごとに異なっていても構いません。ただし、要素の型が要素ごとに異なっている場合、要素に応じて処理を変えなければならないので注意が必要です。したがって、要素の型は同一にする方が一般的です。
  
  リストの要素にリストを入れることができます。これによって多次元配列を実現することができます。
```
nums = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]	# 3x3の2次元配列
```
- list関数
  
  list関数を使ってリストを作ることもできます。
  
  num = list()のようにすると空のリストが作成されます。
  
  list関数の引数に、リスト、タプル、文字列、rangeなどiterable（イテラブル、反復可能オブジェクト）を渡すとその反復内容から新たなリストを作成します。
```
num = list((1, 2, 3, 4, 5))
print(num)
>> [1, 2, 3, 4, 5]
chars = list("ABCDEF")
print(chars)
>> ['A', 'B', 'C', 'D', 'E', 'F']
```
- range関数
  
  for文でよく使われるrange関数は、規則的に連続する数値のiterableを出力する関数です。
  
  range(初期値、終端値、加算値）で、引数が1個のときは終端値のみ（初期値は0、加算値は1）、引数が2個のときは初期値と終端値（加算値は1）となります。
  
  前述のlist関数の引数として使用することで、規則的に連続する数値のリストを作成することができます。
```
nums = list(range(10))
print(nums)
>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
nums = list(range(1, 10, 2))
print(nums)
>> [1, 3, 5, 7, 9]
```
- *演算子
  
  リストに*演算子を適用するとリストの内容を指定した回数繰り返したリストを返します。
```
nums = [1, 2, 3] * 3
print(nums)
>> [1, 2, 3, 1, 2, 3, 1, 2, 3]
nones = [None] * 3
print(nones)
>> [None, None, None]
```
  *演算子はコピーして繰り返されるので、要素がリストなどの場合、同じリストが繰り返され、どれかのリストを変更するとコピーされた全てのリストの内容まで変更されてしまうので注意が必要です。
```
nums = [[1, 2, 3]] * 3
print(nums)
>> [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
nums[0][0] = 4
print(nums)
>> [[4, 2, 3], [4, 2, 3], [4, 2, 3]]
```
  したがって、多次元配列を作成する時に*演算子を使うことはできません。多次元配列を作成する際には、次のレッスンで学ぶ内包表記を使用します。
- appendメソッド
  
  リストに要素を追加するにはappendメソッドを使用します。 リスト.append(要素)で要素をリストの最後尾に追加します。
```
nums = []
nums.append(1)
nums.append(2)
nums.append(3)
print(nums)
>> [1, 2, 3]
```
- len関数
  
  len(リスト)のようにリストを引数としてlen関数を実行するとリストの長さを返します。
```
nums = [1, 2, 3, 4, 5]
print(len(nums))
>> 5
```
- countメソッド
  
  リストに引数の要素が何個含まれているかを返すのがcountメソッドで、リスト.count(要素)のように使用します。
```
nums = [1, 1, 2, 3, 3]
print(nums.count(1))
>> 2
print(nums.count(2))
>> 1
print(nums.count(3))
>> 2
print(nums.count(0))
>> 0
```

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習51〜60.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習51〜60というタイトルの演習問題が表示されます。

課題51から課題60までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

まとめ

今回はPython演習として、書式化のつづき（書式化演算子とformatメソッド）とリストを行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。

レッスン125

Mon, 24 Aug 2026 15:00:00 +0900

Python演習ドリル200 基礎練習31〜40, 41〜50

Pythonプログラムを学び始めた方向けの演習ドリルです。

今回は、基礎練習の31〜40と41〜50です。

jupyterとjupyter notebook

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

文字列処理
- for文による文字列の逐次処理
  
  for c in "文字列":のように、文字列をループ文で処理すると、変数cに文字列の文字が文字列数分、1文字ずつ格納され、ループ処理されます。
  
  例えば、以下のように文字列をfor文で処理し、print()関数で出力すると、（出力結果）のように出力されます。
```
for c in "abcde":
	print(c)
```
  （出力結果）
```
a
b
c
d
e
```
  文字列には英数だけでなく、日本語（漢字、かな、カナ）も使用でき、全て1文字単位で処理されます。
- enumerate()関数
  
  for i, c in enumerate("文字列"):のように文字列をenumerate()関数で処理すると、変数iには0から始まり1ずつ増えるインデックスの値が格納され、変数cには文字列の文字が1文字ずつ格納され、ループ処理されます。
  
  例えば、以下のように文字列for文で処理し、print()関数で出力すると、出力結果のように出力されます。
```
for i, c in enumerate("abcde"):
	print(i, c)
```
  （出力結果）
```
0 a
1 b
2 c
3 d
4 e
```
  enumerate("文字列", 開始インデックス）というようにenumerate関数の2番目の引数に開始インデックス（例えば1）を指定すると、開始インデックス(例えば1)から始まり1ずつ増えたインデックスの値が変数iに格納されます。（変数cに格納される文字は開始インデックスの有無・内容によって変わりることはありません）
- 文字列のスライス
  
  "文字列"[i]のようにインデックスを指定すると、文字列のi番目（0から始まる値）の文字を取得できます。
  
  "文字列"[a:b]のように指定すると文字列のa番目からb-1番目（0から始まる値）の文字列を取得できます。
  
  "文字列"[a:b:c]のように指定すると、文字列のa番目からb-1番目（0から始まる値）までの文字をc-1文字おきの（cずつずらした）文字列を取得できます。
  
  "文字列"[a:b]および"文字列"[a:b:c]のa、b、およびcは省略可能で、省略した場合、それぞれ文字列の先頭（cが負の場合は末尾）、文字列の末尾（cが負の場合は先頭）、1と解釈されます。 aとbを省略した場合は、cの符号とは関係なく全ての要素の範囲が選択されます。（もちろん、cの値によって実際に取得される文字列は異なります）
```
	"abcde"[1] 		# "b"
	"abcde"[1:4]	# "bcd"
	"abcde"[1:5:2]	# "bd"
	"abcde"[:]		# "abcde"
	"abcde"[:3]		# "abc"
	"abcde"[2:]		# "cde"
```
  インデックスには負の値も使用することができます。負の値は-1が文字列の最後尾の位置、-1増えるごとに1つずつ前の位置を示し、文字列の先頭は-文字列の長さになります。
  
  スライスで指定する位置（インデックス）は要素と要素の間を指す、と考えると理解しやすいです。
```
 +---+---+---+---+---+---+
 | a | b | c | d | e | f |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
```
  cのc-1文字おきの（cずつずらした）値にも負の値を指定することができ、負の場合、末尾方向から逆順に要素を取得します。 "abcde"[::-1]のように指定すると、全ての文字を文末から文頭に1文字ずつ逆方向に取得する、すなわち、文字列を反転して出力することになります。
  
  cが省略されるか、正の値の場合は、正のインデックスに換算してa < b、負の場合は、正のインデックスに換算してa > bでないと何も取得されません。(空の文字列"“になる）
```
	"abcde"[-1] 	# "e"
	"abcde"[1:-1]	# "bcd"
	"abcde"[::-1]	# "edcba"
```
  なお、文字列を反転する方法としてはreverse()という関数を用いることもできます。
- in（含まれる）
  
  "文字列1" in "文字列2"という式で、文字列2の中に文字列1が含まれているかを判断することができ、含まれていればTrue、そうでなければFalseを返します。
- count（含まれる数を返す）
  
  "文字列1".count("文字列2")という関数で、文字列1に文字列2が何個含まれているかの数を返します。
- stringモジュールの定数
  
  stringモジュールをimportすると以下のような文字列定数を使うことができます。
  - string.ascii_lowercase
    
    英小文字abcdefghijklmnopqrstuvwxyzの文字列
  - string.ascii_uppercase
    
    英大文字ABCDEFGHIJKLMNOPQRSTUVWXYZの文字列
  - string.ascii_letters
    
    前述のstring.ascii_lowercaseとstring.ascii_uppercaseを合わせた文字列
  - string.digits
    
    数字0123456789の文字列
  - string.hexdigits
    
    16進数字0123456789abcdefABCDEFの文字列
  - string.octdigits
    
    8進数字01234567の文字列
  - string.punctuation
    
    区切り文字として扱われるASCII文字!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~の文字列
  - string.whitespace
    
    空白文字(whitespace)として扱われるASCII文字の文字列
  - string.printable
    
    上述のstring.digits、string.letters、string.punctuation及びstring.whitespaceを合わせた文字列
- joinメソッド
  
  "区切り文字".join("文字列")で、文字列の各文字を指定の区切り文字で区切った1つの文字列を出力します。
```
"->".join("abcde")		# "a->b->c->d->e"
```
- splitメソッド
  
  "文字列".split("区切り文字")で、1つの文字列を指定の区切り文字で区切り、区切った各文字列を文字列の配列として出力します。
```
"a,b,c,d,e".split(",")	# ["a","b","c","d","e"]
```
  なお、split()のように区切り文字を指定しない場合、空白文字（スペース、改行、タブなど）を区切り文字とし、連続する空白文字はまとめて１つの空白文字として処理されます。
```
"a    b  c d".split()		# ["a","b","c","d"]
```
- stripメソッド
  
  "文字列".strip()で文字列の先頭と末尾にある余分なスペース記号（スペースや改行など）を全て除去して出力します。
```
"   abcde   \n".strip()	# "abcde"
```
- replaceメソッド
  
  "文字列1".replace("文字列2", "文字列3")で、文字列1中の文字列2を全て文字列3に置換えて出力します。
```
"abcaab".replace("a", "_")	# "_bc__b"
```
- chr関数とord関数
  
  各文字には、文字コードという文字1つ1つに付けられた値があります。例えばaは97、bは98というふうに、小文字のアルファベットは97から始まる文字コードが付けられています。大文字は65から始まり、数字は48から始まります。
  
  文字コードの値を文字に変換するにはchrという関数を使用し、chr(97)のようにすると、数値の文字コード値97を文字"a"に変換できます。同様にordという関数を使用し、ord("a")のようにすると、文字"a"を数値の文字コード値97に変換できます。なお、ord関数に2文字以上の文字列を渡すとエラーになります。
```
chr(97)		# "a"
ord("a")	# 97
```
- 大文字・小文字変換メソッド
  - capitalizeメソッド
    
    文字列の最初の文字を大文字に変換します。
```
	print("hello".captalize())
	>> Hello
```
  - lowerメソッド
    
    文字列を全て小文字に変換します。
```
	print("HELLO".lower())
	>> hello
```
  - upperメソッド
    
    文字列を全て大文字に変換します。
```
	print("hello".upper())
	>> HELLO
```
  - titleメソッド
    
    各単語の最初の文字を大文字に変換します。
```
	print("hello world".upper())
	>> Hello World
```
- 文字列の判定メソッド
  - isalnumメソッド
    
    文字列が英数字のみで構成されているか否かを判定します。
```
	print("hello123".isalnum())
	>> True
```
  - isalphaメソッド
    
    文字列が英字（アルファベット）のみで構成されているか否かを判定します。
```
	print("Hello".isalnum())
	>> True
```
  - isdigitメソッド
    
    文字列が数字のみで構成されているか否かを判定します。
```
	print("123".isdigit())
	>> True
```
  - islowerメソッド
    
    文字列が英字（アルファベット）の小文字のみで構成されているか否かを判定します。
```
	print("hello".isdigit())
	>> True
```
  - isupperメソッド
    
    文字列が英字（アルファベット）の大文字のみで構成されているか否かを判定します。
```
	print("HELLO".isdigit())
	>> True
```
  - isspaceメソッド
    
    文字列が空白文字のみで構成されているか否かを判定します。
```
	print(" \t\n".isdigit())
	>> True
```
  - istitleメソッド
    
    文字列の各単語の最初の文字が英字大文字であるかどうかを判定します。
```
	print("Hello World".isdigit())
	>> True
```
書式化
- f文字列のおさらいと追加項目
  
  桁数のNは定数値です。また、10進数の数を示すdは省略可能です。
  - 変数xの値を文字列に入れる場合
    
    f"文字列1{x}文字列2"
  - 変数xの10進数の値をコンマ（,）による3桁ずつの桁区切りで表示したい場合
    
    f"{x:,d}" f"{x:N,d}"（スペース埋めN桁表示）
  - 変数xの値を2, 8, 10, 16進数でスペースで埋めてN桁で表示したい場合
    
    f"{x:Nb}",f"{x:No}", f"{x:Nd}", f"{x:Nx}"
  - 変数xの値を2, 8, 10, 16進数で0で埋めてN桁で表示したい場合
    
    f"{x:0Nb}",f"{x:0No}", f"{x:0Nd}", f"{x:0Nx}"
  - 変数xの値を2, 8, 16進数でそれぞれ頭に0b,0o,0xを付けてN桁で表示したい場合
    
    f"{x:#Nb}", f"{x:#Nd}", f"{x:#Nx}"
  - 変数sの文字列を文字cで埋めてn桁で表示したい場合（cが省略されるとスペース埋め）
    - 右寄せ
      
      f"{s:c>Ns}"
    - 中央寄せ
      
      f"{x:c^Ns)"
    - 左寄せ
      
      f"{s:c<Ns}"
    右寄せ、中央寄せ、左寄せは、文字列だけでなく、数値に対しても使用できます。その際は、右端のsの部分がb,o,d,xなどになります。

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習31〜40.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習31〜40というタイトルの演習問題が表示されます。

課題31から課題40までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

終わったら、ホーム画面に戻って、Python演習ドリル200基礎練習41〜50.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習41〜50というタイトルの演習問題が表示されます。

同様に課題41から課題50までの課題の内容にしたがってPythonプログラムを書き、出力結果と一致するか確認してください。

まとめ

今回はPython演習として、文字列処理と書式化（f文字列）を行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。

レッスン124

Sun, 23 Aug 2026 16:00:00 +0900

Python演習ドリル200 基礎練習21〜30

Pythonプログラムを学び始めた方向けの演習ドリルです。

今回は、基礎練習の21〜30です。

jupyterとjupyter notebook

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

ビット処理

数値を2進数として、各桁（ビット）単位に処理することをビット処理と言います。
- ビット演算
  
  各桁（ビット）ごとに、演算処理を行うことをビット演算といいます。
  
  ビット演算には条件分岐の時に説明した論理演算同様、and、or、not、xorの４種類の演算子があります。
  
  ビット演算では論理演算とは異なり、「True／False」の代わりに「0／1」というビット値（各ビットの値）を使い、４つの演算子はそれぞれ、&、|、~、^というビット演算子で表現します。
  
  変数aと変数bをビット演算すると、各変数を2進数にしたときの各桁の値ごとにそれぞれ演算し、その結果を出力します。
  
  例えば変数aと変数bにそれぞれ10進数で5と3の値が入っているとすると、ビットでは以下のように表現されます。
  
  変数 10進数 2進数 4ビット目 3ビット目 2ビット目 1ビット目
  
  a 5 101 0 1 0 1
  
  b 3 11 0 0 1 1
  
  a & bでビットのand処理を行うと、
  - 1ビット目：　1 & 1 = 1
  - 2ビット目： 0 & 1 = 0
  - 3ビット目：　1 & 0 = 0
  - 4ビット目： 0 & 0 = 0
  なので0001というビット値（2進数）になり、10進数でいうと1の値になります。
  
  同様にa | bでビットのor処理を行うと、
  - 1ビット目：　1 | 1 = 1
  - 2ビット目： 0 | 1 = 1
  - 3ビット目：　1 | 0 = 1
  - 4ビット目： 0 | 0 = 0
  なので0111というビット値（2進数）になり、10進数でいうと7に値になります。
  
  上の表では簡易的に4桁のビットで表現しましたが、Pythonの場合、桁数に上限はなく、全ての桁のビットで処理が行われます。なお、通常のプログラミング言語では32桁または64桁のビットで処理が行われます。
  
  Pythonで~(not)を使用すると、値は負の値として表示されます。正の値で表現したい場合は、必要な桁数分1で埋まった値（8桁なら0b11111111）とand処理（&）を行う必要があります。
- ビットのシフト
  
  x >> yという演算子を使用すると、x変数の各桁のビット値をy変数で指定した値分、右方向の桁（下位の桁）に移動した値が得られます。演算結果をx変数に設定し直したい場合は、x >>= yのように記述します。
  
  例えば変数aに2進数で1010（10進数で10）の値が入っているとa >> 1の値は2進数で0101（10進数で5）です。シフトした最上位（左端）の桁には0が入ります。 1つシフトするごとに10進数の値は元の値の2分の1（小数点切り捨て）になります。
  
  x << yという演算子を使用すると、x変数の各桁のビット値をy変数で指定した値分、左方向の桁（上位の桁）に移動した値が得られます。演算結果をx変数に設定し直したい場合は、x <<= yのように記述します。
  
  例えば変数aに2進数で1010（10進数で10）の値が入っているとa << 1の値は2進数で10100（10進数で20）です。シフトした最下位（右端）の桁には0が入ります。 1つシフトするごとに10進数の値は元の値の2倍になります。
- ビットのセット・クリア
  
  Pythonでは、ある桁のビット値を1にしたり（セット）、0にしたり（クリア）する演算子はありません。このような処理を行いたい場合、以下のようにシフトとビット演算を組み合わせることで、セット・クリアを実行します。
  - ビットのセット
  変数xの右（下位）から0から数えてn番目のビットをセットしたい場合の式は、x = x | (1 << n)となります。 x |= 1 << nのように記述することもできます。
  - ビットのクリア
  変数xの右（下位）から0から数えてn番目のビットをクリアしたい場合の式は、x = x & ~(1 << n)となります。 x &= ~(1 << n)のように記述することもできます。
2進数の出力方法

10進数の2進数の値に変換するにはbin()関数を使います。出力結果は0bXXXX（Xは0か1の値）のような文字列になります。

またf文字列の中の変数値を2進数表記で出力することもできます。

f"{変数:b}"とすると、変数値は0bが付かない2進数値で表示されます。その際、{変数:8b}のようにbの前に数字を入れると桁数が指定でき、桁数に足りない分は左側をスペースで埋めてくれます。また、{変数:08b}のように数字の前に0を入れると桁数に足りない分は左側を0で埋めてくれます。
累乗の演算子

aのn乗というのを累乗と呼びます。 aのn乗とは、aをn回かけ合わせた結果のことです。

Pythonには**という累乗の演算子が用意されているのでaのn乗であればa ** nのように簡単に演算できます。

変数	10進数	2進数	4ビット目	3ビット目	2ビット目	1ビット目
a	5	101	0	1	0	1
b	3	11	0	0	1	1

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習21〜30.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習21〜30というタイトルの演習問題が表示されます。

課題21から課題30までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

まとめ

今回はPython演習として、繰り返しの続きとビット処理を行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。

レッスン123

Sat, 22 Aug 2026 14:00:00 +0900

Python演習ドリル200 基礎練習11〜20

Pythonプログラムを学び始めた方向けの演習ドリルです。

今回は、基礎練習の11〜20です。

jupyterとjupyter notebook

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

条件分岐（論理演算子）

複数の条件を組み合わたものを条件とする場合、以下のような論理演算子を使います。
- and
  
  条件1 and 条件2で、「条件1かつ条件2」つまり、両方の条件が満たされた時のみ条件が満たされます
- or
  
  条件1 or 条件2で、「条件1または条件2」つまり、どちらかの条件を満たされた時、条件が満たされます（両方の条件が満たされていても良い）
- not
  
  not 条件1で、条件1が満たされない時、条件が満たされます
- xor
  
  条件1 xor 条件2で、「条件1排他的にまたは条件2」つまり、どちらか一方の条件のみ満たされた時に、条件が満たされます（両方の条件が満たされている時や両方とも条件が満たされていないときは、条件は満たされない）
なお、x、y、zが全て等しい場合の条件は、論理演算子を使わず、x == y == zのように書くこともできます。
条件演算子

条件演算子はX if 条件 else Yという1行で、条件が満たされればXの値に、満たされなければYの値になります。これを使って、条件によって変数に設定する値を変えたり、print関数などの関数の引数の値を変えたりすることができます。

例えば変数xが0以上なら"0以上"、それ以外（0未満）なら"0未満"と表示するprint関数は、条件演算子を使って以下のように記述できます。
```
	print("0以上" if x >= 0 else "0未満")
```
このとき文末のコロン（:）は不要です。
ループ（for文）

以下のように所定の回数ループする場合は、for i in range(n):を使い、forの下にインデントで（字下げして）書かれたプログラム文（ブロック）をn回繰り返し、実行します。
```
for i in range(10):
	print("AAA")		# for文の対象、10回繰り返す
	print("BBB")		# for文の対象、10回繰り返す
print("CCC")			# for文の対象でない
```
なお、変数iには各ループごとに0から1ずつ加算された値がn-1まで入ります。 range(a, b)とすると各ループごとにaから1ずつ加算された値がiに入り、iの値がb以上になったらループを抜けます。 range(a, b, c)とすると各ループごとにaからcずつ加算された値がiに入り、iの値がb以上になったらループを抜けます。

結果としてrange(a, b)とすると変数iには順にa, a+1, a+2, ..., b-1の値が入り、ループ処理が行われます。（最後の値がbでないことに注意してください）

変数iの値を使用しない場合はfor _ in range(n):のように変数名を_にして、変数を使用しないようにすることができます。

cには負の値を入れることもできます。その場合、変数iには最初にaの値が入り、次にa+c（cが負なのでaより小さい値）が入り、iの値がc以下になったら、ループを終了します。

結果としてrange(a, b, -1)とすると変数iには順にa, a-1, a-2, ..., b+1の値が入り、ループ処理が行われます。（最後の値がbでないことに注意してください）
ループ（while文）

以下のように、ある条件が満たされている間ループする場合は、while 条件:を使い、whileの下にインデントで（字下げして）書かれたプログラムを条件が満たされるまで繰り返し実行します。
```
x = 10
while x > 0:			# xが0より大きい間繰り返す
	print("AAA")		# while文の対象
	x -= 1				# while文の対象、xを1つずつ減らす
print("BBB")			# while文の対象でない
```
ループ処理の中で条件が満たされなくならないと無限ループといってループを無限に繰り返し、プログラムが終わらなくなってしまいます。例えば上記プログラムでx -= 1の代わりにx += 1とすると、xはいくら立ってもx > 0のままなので、無限ループになってしまいます。

条件にTrueを指定して、意図的に無限ループを繰り返させることもあります。もちろん、このままだとプログラムが終わらなくなってしまうので、ループの中にbreakを指定してこのループから抜けさせます。

また、ループの途中でcontinueを指定すると、ループの途中で処理を中断して、ループの先頭に戻り、次のループを続けさせることができます。
```
while True:	# 無限ループ
	i = int(input("正の値を入れてください"))	# キーボードから数値を入力
	if i > 0:		# 値が正だったら
		break		# ループから抜ける
	elif i == 0:	# 値が0だったら
		continue	# ループの先頭に戻って処理を続ける
	print("負の値が入力されました")	# メッセージを出力してループの先頭に戻る
print(i)	# breakでループから抜けた後の処理
```
なお、breakとcontinueはfor文でも使用することができます。
その他
- 配列
  
  [値1, 値2..., 値n]という記述で、n個の値をまとめて配列を作ることができます。
  
  配列をprint関数で表示すると[値1, 値2..., 値n]のように出力されます。
  
  配列の各値は0から始まるインデックスを使って配列[0]、配列[1]、… 配列[n-1]のようにして値を取り出したり、値を変更したりすることができます。
  
  なお、配列の要素を全て取り出す場合、変数1, 変数2, ... 変数n = 配列のようにして変数に直接入れて取り出すこともできます。
  
  配列に対して、以下のようないろいろな関数で計算ができます。
  - sum(配列)
    
    配列の総和を返す
  - min(配列)
    
    配列の最小値を返す
  - max(配列)
    
    配列の最大値を返す
  - mean(配列)
    
    配列の平均値を返す
  - sorted(配列)
    
    昇順（小さい順）にソートした配列を返す
  - sorted(配列, reverse=True)
    
    降順（大きい順）にソートした配列を返す
- ランダム
  
  プログラムの先頭でimport randomを宣言し、random.randint(x, y)を実行すると、x〜yの数値をランダムに返します。
- スリープ
  
  プログラムの先頭でimport timeを宣言し、time.sleep(秒)を実行すると、指定の秒数処理を待ってから処理が続けられます。

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習11〜20.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習11〜20というタイトルの演習問題が表示されます。

課題11から課題20までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

まとめ

今回はPython演習として、条件分岐と繰り返し処理の演習を行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。

レッスン122

Sat, 22 Aug 2026 09:00:00 +0900

Python演習ドリル200 基礎練習1〜10

Pythonプログラムを学び始めた方向けの演習ドリルです。

まずは、基礎練習の1〜10から始めましょう。

jupyterとjupyter notebook

print(ord(“0”)) 本演習ではjupyter notebookを使用します。インストールされているか確認してください。インストールされていない場合、jupyterとjupyter notebookのインストール方法については、レッスン33を参照してください。

演習前の基礎学習

実際にjupyter notebookを使用して演習を行う前に、演習の中で使用するPythonの機能について学習しましょう。

画面への出力(print関数)

Pythonで画面に文字列や数値を出力するにはprint関数を使用します。

print("文字列")を実行すれば改行付きで文字列が出力されます。

引数で、end="XX"を指定すると、改行の代わりに文字列の末尾にXXが付いて出力されます。 end=""（空文字列）を指定すれば、文字列の末尾は改行されず、何も付与されないで文字列だけが出力されます。

print(変数)を実行すれば、変数の値が出力されます。変数が数値の場合は、数値が出力されます。配列の場合は[要素1, 要素2,...]のように全体が[]でくくられ、各要素がカンマ(,)で区切られて出力されます。

print(変数1, 変数2)のように「,」で区切って複数の変数を指定すると、各変数の値はスペース区切りで出力されます。

引数で、sep="XX"を指定すると、スペース区切りの代わりにXX区切りで出力されます。 改行区切りにしたければsep="\n"を指定し、区切りなしで（くっつけて）出力したい場合はsep=""を指定します。

文字列の中に変数の値を入れて出力したい場合はf文字列を使用します。 f"文字列1{変数}文字列2"のように記述して、文字列の中に{変数}を埋め込むことができます。 {変数}の部分には変数だけでなく、関数や式も記述することができます。
キーボードからの入力(input関数）と数値変換

Pythonでキーボードから文字列や数値を入力するのはinput関数を使用します。

s = input()のようにすれば、画面に何も出力されずに入力待ちになり、文字列や数値を入れて改行すると改行抜きで文字列が変数sに入ります。

入力時に画面に文字列を表示したい場合はs = input("文字列")のように引数として文字列を入れます。文字列の代わりに先ほど説明したf文字列を使用することもできます。

input()の戻り値は常に文字列です。数値に変換したい場合はint("文字列")関数（整数値）、float("文字列")関数（実数値、小数点のある値）で変換を行う必要があります。

int関数では10進数の文字列を整数に変換します。 10進数の値を2, 8, 16進数の文字列に変換するには、それぞれbin(),oct(),hex()という関数を使用します。これら2, 8, 16進数の文字列には先頭にそれぞれ0b、0o、0xという進数を識別する文字列が付きます。
条件分岐（if,ifelse,else）

入力した値によって処理を分けたい場合はif,ifelse,elseという条件式を使用します。

例えばxの値が0以上のときだけ表示したい場合は、以下のように記述します。
```
if x >= 0:		# 行の末尾に「:」を忘れずに付けること
	print(x)	# インデントで字下げをすること
```
加えて、0以上以外のときに「マイナス」と表示するようにしたい場合は、以下のように記述します。
```
if x >= 0:
	print(x)
else:		# 上記の条件以外
	print("マイナス")
```
xが0より大きければ「プラス」、0より小さければ「マイナス」、それ以外（0）なら「ゼロ」と表示するようにしたい場合は、以下のように記述します。
```
if x > 0:		# 条件１
	print("プラス")
elif x < 0:	# 条件１以外で条件２
	print("マイナス")
else:		# それ以外（条件１でも条件２でもない）
	print("ゼロ")
```
elifはelse ifという意味で、1つ前のif（あるいはelif）の条件が満たされない場合のみ、処理されます。例えば以下のような条件の場合、xが10であればelifの条件を満たしていますが、先にifの条件も満たしているので、先のifの方が処理され、elifは処理されません。
```
if x >= 5:
	print("xは5以上")
elif x >= 0:
	print("xは0以上")
else:
	print("xは0未満")
```
他のプログラミング言語では一般的に文を{...}で囲むことでブロック（複文）を構成しますが、Pythonではインデント（行頭の空白文字の数）が重要な意味を持ち、同じ数の空白やタブ文字でインデントされた文がブロックとみなされます。
```
a = 3
if a == 5:
	print("AAA")		# if文の対象
	print("BBB")		# if文の対象
print("CCC")			# if文の対象ではない
```
インデントは通常4個の空白文字を使用します。
```
if a = 5:
    print("AAA")	# 4個の空白文字
```
インデントにタブ文字(tab)を用いる場合、半角スペースを用いるか、タブ文字を用いるか統一が必要です。統一されていない場合、インデントエラーが発生することがあります。
```
if a == 5:
    print("AAA")		# この行は半角4個のインデントなのに
	print("BBB")	# この行はタブ1個のインデントなので見た目は一緒でも空白文字の数が違うのでインデントエラーになる
```
エディターによってはタブを自動的に半角スペース4個に置き換える機能もあるので、このような機能を使用すれば、タブと半角スペースの共存によるエラーを防ぐことができます。

また、if、ifelse、elseなどの文の行末には「:」を付けるのを忘れないでください。

演習

それでは実際にjupyter notebookを使用して、演習を行います。

コマンドラインからgit pullを実行してmcc1フォルダに最新のファイルをダウンロードしてください。

ターミナルのコマンドラインからcd mcc1/code/jupyterを実行して、jupyterフォルダに移動し、jupyter notebookを実行してください。

すると、ブラウザが起動し、jupyterのホーム画面が表示されます。

その中からPython演習ドリル200基礎練習1〜10.ipynbをクリックしてください。

そうするとPython演習ドリル200基礎練習1〜10というタイトルの演習問題が表示されます。

課題1から課題10までありますので、課題の内容にしたがって、In[]:の部分にPythonプログラムを書いてください。書き終わったら、画面上の ▶| Run というアイコンをクリックすると、今書いたPythonプログラムが実行されます。

出力結果が課題の（実行画面）と一致するか確認してください。

どうしても正解がわからないときは、▶プログラム例 をクリックすると、正解例のPythonプログラムが表示されます。

まとめ

今回はPython演習として、入出力と条件分岐の演習を行いました。

今後も新しい演習問題を追加していきますので、演習を通じてPythonを学んでいきましょう。