【Python】「みんなのPython第四版」の学習記録

みんなのPython第四版 目次

Chapter 01 プログラミング言語Python
  01 Pythonの魅力
  02 Python(Anaconda)の入手とインストール
  03 インタラクティブシェル(対話型シェル)を使う
  04 ファイルにPythonのプログラムを書く
  05 Jupyter Notebookを使う
Chapter 02 Pythonでプログラミングをはじめよう
  01 数値を使う
  02 変数を使う
  03 文字列を使う
  04 リストを使う
   convert_number.py
  05 for文でループを使う
   month_tuple.py
   JanKenPon.py
  06 if文で条件分岐をする
  07 関数を使う
  08 モジュールを使う
   ramdom_1.py
   ramdom_2.py
Chapter 03 Pythonの基礎をマスターする
  01 ディクショナリ(辞書)を使う
   purple_dict.py
   convert_number.py
   int2str_str2int.py
  02 set(集合)を使う
   logical_operation_by_set.py
  03 タプルを使う
   month_tuple.py
   tuple_dict.py
  04 if文の応用
   lt_le_gt_ge.py
  05 ループの応用
  06 関数の応用
   int2str_str2int.py
Chapter 04 組み込み型を使いこなす
  01 オブジェクトとしての組み込み型
  02 数値型を操作する
   int2str_str2int.py
  03 文字列型を使いこなす
   s_split.py
   s_join.py
   format_1.py
   format_2.py
   format_3.py
  04 リスト型,タプル型を使いこなす
   list_sort.py
   slice_1.py
  05 set型を使いこなす
  06 ディクショナリ型を使いこなす
  07 if文と組み込み型
  08 for文と組み込み型
   zip.py
  09 関数と組み込み型
  10 Pythonの文字列と日本語
  11 Pythonのファイル処理
Chapter 05 関数型プログラミング
  01 関数型プログラミングとは何か
   purple_dict.py
  02 内包表記(コンプリヘンション)
   s_split_comprehension.py
   s_swapping_comprehension.py
   list_sort_lambda.py
  03 イテレータを使う
  04 ジェネレータを使う
  05 高階関数とデコレータ
   callback.py
Chapter 06 クラスとオブジェクト指向開発
  01 Pythonでクラスを使う
  02 クラスを作る
   callback.py
Chapter 07 クラスの継承と高度なオブジェクト指向機能
  01 クラスを継承する
  02 特殊メソッドを利用する
  03 組み込み型を継承する
Chapter 8 モジュール
  01 モジュールファイルを作る
  02 モジュールの階層構造(パッケージ)
  03 モジュールを利用する際の注意点
  04 サードパーティーのモジュールを使う
Chapter 9 スコープとオブジェクト
  01 名前空間,スコープ
  02 純粋オブジェクト指向言語としてのPython
Chapter 10 例外処理
  01 Pythonの例外処理
  02 良く起こるエラーや例外と対策
   purple_dict.py
Chapter 11 標準ライブラリを使う
  01 標準ライブラリのインポート
  02 データ構造
  03 日時データの扱い「datetime,calendar」
  04 正規表現「re」
  05 システムパラメータを取得,操作する「sys」
  06 ファイル,プロセスなどOS依存の情報を取得,操作する「os」
  07 数学関数を利用する「math」「random」
  08 インターネット上のデータを取得する「urllib」
  09 文字列ベースのバーチャルなファイルを作る「io.StringIO」
  10 CSV(カンマ区切り)ファイルの操作「csv」
  11 オブジェクトの永続化とシリアライズ「shelve」「pickle」
  12 JSONデータを扱う「json」
Chapter 12 Pythonとデータサイエンス
  01 NumPyとmatplotlib
  02 NumPyを使う
  03 matplotlibを使う
  04 日本の人口を可視化する
  05 Pythonと機械学習
Chapter 13 Python2
  01 Python3とPython2の違い
  02 Python2から3への移行方法
  03 おわりに

 

作成したプログラム

以下、書籍のプログラムをマネしつつ、少しアレンジを加えて作成してみた。

purple_dict.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""

import  traceback

# 辞書の定義
purple = {"ニックネーム"     : "れにちゃん",
          "出身地"           : "神奈川県",
          "キャッチフレーズ" : "感電少女" }

# キーを使って要素を取り出す(P115)
print(purple["出身地"]) #=> 神奈川県

# 辞書の中身を全表示
#=> {'出身地': '神奈川県', 'キャッチフレーズ': '感電少女', 'ニックネーム': 'れにちゃん'}
print(purple)

# 値の変更
#=> {'キャッチフレーズ': '鋼少女', 'ニックネーム': 'れにちゃん', '出身地': '神奈川県'}
purple["キャッチフレーズ"] = "鋼少女"
print(purple)

# 要素の追加
#=> {'ニックネーム': 'れにちゃん', '出身地': '神奈川県', 'キャッチフレーズ': '鋼少女', '生年月日': '1993年6月21日'}
purple["生年月日"] = "1993年6月21日"
print(purple)

# 要素の削除
#=> {'生年月日': '1993年6月21日', 'キャッチフレーズ': '鋼少女', '出身地': '神奈川県'}
del purple["ニックネーム"]
print(purple)

# 存在しないキーでアクセスする
#=> KeyError: '性別' が発生する
try:
    print(purple["性別"])
except:
    ex = traceback.print_exc()
    print('エラー原因は{e}です'.format(e=ex))
finally:
    pass


# キーの存在確認をする
def is_key_exist( keyword ):
    for key in purple:
        if keyword == key:
            return purple[key]
    return  "見つかりませんでした"

# 存在確認したいキーの一覧は読み取り専用にする
keys = ( "性別", "生年月日" )

for key in keys:
    ret = is_key_exist(key)
    print('キーワード"{k}"に対応する値 => {r}'.format(k=key, r=ret))

 

convert_number.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
def convert_number(num):
    # アラビア数字とローマ数字の対応表を辞書に定義する
    roman_nums = {1:"Ⅰ", 2:"Ⅱ", 3:"Ⅲ", 4:"Ⅳ", 5:"Ⅴ",
                  6:"Ⅵ", 7:"Ⅶ", 8:"Ⅷ", 9:"Ⅸ"}
    # キーが存在するかを in で調べる
    if num in roman_nums:
        return roman_nums[num]
    else:
        return "変換不可です"
        

nums = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]

if __name__ == '__main__':
    for i in nums:
        print(i, convert_number(i))

 

logical_operation_by_set.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版 (P126)
set には数値や文字列を要素として設定することが可能である。
一方で要素が変化するリストや辞書は設定することができない。
"""
def set_union( a: "set型の引数",
               b: "set型の引数" ) -> "戻り値: 和集合≒ORの結果" :
    return ( a | b )

def set_differ( a: "set型の引数",
                b: "set型の引数" ) -> "戻り値: 差集合" :
    return ( a - b )

def set_and( a: "set型の引数",
             b: "set型の引数" ) -> "戻り値: 交わり≒ ANDの結果" :
    return ( a & b )

def set_xor( a: "set型の引数",
             b: "set型の引数" ) -> "戻り値: 対象差=排他論理和=XOR の結果" :
    return ( a ^ b )

def conv_list_2_set( codon: "リスト" ) -> "戻り値: set(集合)" :
    return set(codon)

if __name__ == '__main__':

    # 和集合を得る
    prime = { 2, 3, 5, 7, 13, 17 }   # 素数
    fib   = { 1, 1, 2, 3, 5, 8, 13 } # フィボナッチ数
    print(set_union( prime, fib ))
    print( set_union.__annotations__ )
    #=> {1, 2, 3, 5, 7, 8, 13, 17}

    # 差集合を得る
    dice = { 1, 2, 3, 4, 5, 6 } # サイコロの目
    even = { 2, 4, 6, 8, 10 }   # 偶数
    print(set_differ( dice, even ))
    print( set_differ.__annotations__ )
    #=> {1, 3, 5}

    # 論理和を得る
    prefs = { "北海道", "青森", "秋田", "岩手" }    # 都道府県
    capital = { "札幌", "青森", "秋田", "盛岡" }    # 県庁所在地
    print(set_and( prefs, capital ))
    print( set_and.__annotations__ )
    #=> {'秋田', '青森'}

    # 対象差を得る
    print(set_xor( prefs, capital ))
    print( set_xor.__annotations__ )
    #=> {'北海道', '岩手', '盛岡', '札幌'}

    # リストを set に変換する
    codon = [ 'ATG', 'GGC', 'TCC', 'AAG', 'TTC', 'TGG', 'GAC', 'TCC' ]
    s_codon = conv_list_2_set( codon )
    print( s_codon ) #=> {'TTC', 'TGG', 'GAC', 'ATG', 'AAG', 'GGC', 'TCC'}
    print( len(codon), len(s_codon) ) #=> 8 7

    # 要素の検索と set の比較
    prime_fib = set_and(prime, fib) # 2つの交わり(AND)を得る
    values    = { 2, 3, 4, 5, 6, 7, 8, 9, 10,
                    11, 12, 13, 14, 15, 16, 17, 18 }
    normal    = set_differ(set_differ( values, prime ), fib) # 非素数・非フィボナッチ
    for value in values:
        if value in prime_fib:
            print("{0}は素数であり、かつフィボナッチ数でもある".format(value))
        elif value in prime:
            print("{0}は素数である".format(value))
        elif value in normal:
            print("{0}".format(value))

 

month_tuple.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
- タプルは要素の変更ができない (リストと異なる点)
-- month_names[0] = "hoge" が不可ということ
- 要素の重複は許される (set と異なる点)
"""

def print_tuple( t, start:int=1 ):
    for i, val in enumerate( t, start ):
        print( i, val )

month_names = ( "January", "February", "March", "April",
                "May", "June", "July" )

if __name__ == '__main__':
    print_tuple( month_names )

    # タプルの連結は可能
    month_names = month_names + ("August", "September", "October",
                                    "November", "December" )
    print_tuple( month_names )

 

tuple_dict.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
- タプルを辞書のキーとして使うプログラム
-- 緯度と経度をキーにしている。
"""

def search_capitals( loc        : "調べたい緯度・軽度のタプル",
                     isNearMode : "近い所在地を調べるモードか否か" =False ) -> "戻り値 該当する所在地名" :
    capital  = "該当する県庁所在地がありません"
    pref_capitals = {(43.06417, 141.34694) : "北海道(札幌)  ",
                     (40.82444, 140.74   ) : "青森県(青森市)",
                     (39.70361, 141.1525 ) : "岩手県(盛岡市)" }
    if( isNearMode != True ):
        for key in pref_capitals:
            if loc == key:
                capital = (pref_capitals[key])
                break
    else:
        nearest_dist = 10000
        for key in pref_capitals:
            dist = (loc[0]-key[0])**2 + (loc[1]-key[1])**2
        if nearest_dist > dist:
            nearest_dist = dist
            capital      = pref_capitals[key]

    return capital

if __name__ == '__main__':
    locs = [ (39.70361,  141.1525 ) , (41.768793, 140.72881) ]
    print(search_capitals(locs[0]))         #=> 岩手県(盛岡市)
    print(search_capitals(locs[1], True))   #=> 北海道(札幌)
    print(search_capitals.__annotations__)

 

lt_le_gt_ge.py

  • 「0 <= val < 5」 といった書き方ができる。
    • わざわざ 「 0<= val and val < 5 」といった書き方をしなくて良い。
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
values = [ 0, 6, 10, 100 ]

for i, val in enumerate( values, start=0 ):
    if    0 <= val < 5:
        print("values[{i}]={v} ... [ 0 <= val <   5]".format(i=i, v=val))
    elif  5 <= val < 10:
        print("values[{i}]={v} ... [ 5 <= val <  10]".format(i=i, v=val))
    elif 10 <= val < 100:
        print("values[{i}]={v} ... [10 <= val < 100]".format(i=i, v=val))
    else:
        print("values[{i}]={v} ... [ else ]".format(i=i, v=val))

 

JanKenPon.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
from random import randint

hands = { 0:"グー", 1:"チョキ", 2:"パー" }
rules = {
        (0,0):"あいこ", (0,1):"勝ち",   (0,2):"負け",
        (1,0):"負け",   (1,1):"あいこ", (1,2):"勝ち",
        (2,0):"勝ち",   (2,1):"負け",   (2,2):"あいこ"
        }

while True:
    pc_hand = randint(0, 2) # 0<= x <=2 の値を得る
    user_hand_str = input("0:グー, 1:チョキ, 2:パー, 3:終了")
    if user_hand_str == "3":
        break
    if user_hand_str not in ("0", "1", "2"):    # 不正な数値が入力された場合
        continue
    user_hand = int(user_hand_str)
    print("(あなた, COM) = ( "+ hands[user_hand] + ", "+ hands[pc_hand] + " )" )
    print(rules[(user_hand, pc_hand)])

 

random_1.py

  • 「import モジュール名」による random モジュール取り込みパターン。
  • 「from モジュール名 import 関数名」については random_2.py を参照。
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
import random

print(random.random())      # 0 < x < 1 の乱数を得る
print(random.randint(0,6))  # 0 <= x <= 6 の乱数を得る

a_list = [0, 1, 2, 3, 4, 5]
random.shuffle(a_list)      # リストをランダムに並び替える
print(a_list)
print(random.choice(a_list))# リストの要素を1つランダムに選ぶ

 

random_2.py

  • random_1.py とは異なり、「from モジュール名 import 関数名」による random モジュール取り込みパターン。
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
from random import random
from random import randint
from random import shuffle
from random import choice

print(random())      # 0 < x < 1 の乱数を得る
print(randint(0,6))  # 0 <= x <= 6 の乱数を得る

a_list = [0, 1, 2, 3, 4, 5]
shuffle(a_list)      # リストをランダムに並び替える
print(a_list)
print(choice(a_list))# リストの要素を1つランダムに選ぶ

 

int2str_str2int.py

  • 文字列→ 数値 へは int() を使う
2進数文字列の場合 int("0b111", 2)
8進数文字列の場合 int("0o123", 8)
10進数文字列の場合 int("123", 10)
16進数文字列の場合 int("0x10", 16)
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""

# 2進数、8進数、10進数、16進数の各値を文字列で保持した辞書
strval_list = { "bin":"0b1111111111", "oct":"0o1777", "dec":"1023", "hex":"0x3ff" }

# 2進数、8進数、10進数、16進数の各値を整数値で保持した辞書
intval_list = { "bin":0b1111111111, "oct":0o1777, "dec":1023, "hex":0x3fff }

def int2str( value: "値", base: "基底" ) -> "戻り値: 文字列" :
    if   base in { 'b', 'bin' }:
        func=bin
    elif base in { 'o', 'oct' }:
        func=oct
    elif base in { 'd', 'dec' }:
        func=int
    elif base in { 'h', 'hex' }:
        func=hex
    else:
        func=None

    if func != None:
        return func(value)
    else:
        print('Error: invalid base("{0}")'.format(base))
        return 0

def str2int( val_str: "文字列", base: "基底" ) -> "戻り値: 整数値" :
    if   base in { 'b', 'bin' }:
        base = 2
    elif base in { 'o', 'oct' }:
        base = 8
    elif base in { 'd', 'dec' }:
        base = 10
    elif base in { 'h', 'hex' }:
        base = 16
    else:
        base = -1

    if base != -1:
        return int(val_str, base)
    else:
        print('Error: invalid base("{0}")'.format(base))
        return 0


if __name__ == '__main__':
    print("文字列から整数への変換を行います")
    for k, s in strval_list.items():
        retval = 0
        #print(str2int.__annotations__)
        retval = str2int( val_str=s, base=k )
        print("{s} ==> str => int ==> 10進数 {ret}".format(s=s, ret=retval))

    print("整数から文字列への変換を行います")
    for k, v in intval_list.items():
        retstr = ""
        retstr = int2str( value=v, base=k )
        print("{val} ==> int => str ==> '{ret}'".format(val=v, ret=retval))

 

s_split_join.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
# -*- coding: utf-8 -*- 
"""

str_names  = "IV号戦車 LT-38 八九式中戦車 III号突撃砲 M3中戦車" # 戦車名
str_speeds = "38 42 20 40 39"   # 戦車の速度(km/h) ...連続した文字列
str_armor = "80 50 17 50 51"    # 戦車の装甲厚(mm) ...連続した文字列

# まずは戦車の名称を空白単位で分割する。文字列型へのポインタ配列となる。
names = str_names.split(" ")
# 次に戦車の名称をカンマ区切りにする。
chunk_name = ",".join(names)
print("戦車名: ", chunk_name)

# 戦車の速度をカンマ区切りにする。文字列型へのポインタ配列となる。
speeds = str_speeds.split(" ") 
chunk_speeds = ",".join(speeds)
print("走行速度km/h: ", chunk_speeds)

## 装甲厚をカンマ区切りにする。文字列型へのポインタ配列となる。
armors = str_armor.split(" ")   
chunk_armor = ",".join(armors)
print("装甲厚mm: ", chunk_armor)

 

s_split_comprehension.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
str_speeds = "38 42 20 40 39"   # 戦車の速度(km/h) ...連続した文字列

# 戦車の速度をスペースで分割する。文字列型へのポインタ配列となる。
# 内包表記:speeds = str_speeds.split(" ") と同じことをしている↓
speeds = [int(s) for s in str_speeds.split()]
print(speeds)

 

s_swapping_comprehension.py

  • 辞書の内包表記 { キー:値 for 繰り返し変数 in シーケンス (if 条件式) }
  • 辞書の内包表記パターン
  • リストから辞書型を取り出し、小文字に変換するプログラム
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
d = {
        "A-1":"B-1",
        "A-2":"B-2",
        "A-3":"B-3",
        "A-4":"B-4"
    }

swapped = { v:k for k, v in d.items() }
print(swapped)

"""
以下のような結果になる。
        'B-2': 'A-2',
        'B-3': 'A-3',
        'B-4': 'A-4',
        'B-1': 'A-1'
"""


# リスト →  辞書型を行う
names = ["BOB", "burton", "dave", "bob"]    # リストを用意する
unames = {x.lower() for x in names}         # 小文字に変換し、かつ、set として扱う
print(unames)                               # set の結果を表示する
#=> {'burton', 'bob', 'dave'}

 

list_sort.py

  • sortメソッドには引数 key の指定が必須である。
    • ここでは値をそのまま返す key (関数) を設定している。
    • 単純な関数の場合は lambda で済ますことも可能。具体例は list_sort_lambda.py を参照。
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
def faster( spd ):
    return spd

str_speeds = "38 42 20 ?? 40 ?? 39" 
speeds = [ int(s) for s in str_speeds.split() if s.isdigit() ]
print(speeds) #=> [38, 42, 20, 40, 39]

speeds.sort(key=faster, reverse=False)
print(speeds) #=> [20, 38, 39, 40, 42]

 

list_sort_lambda.py

  • sort() に関数を使うパターンは list_sort.py を参照
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
単純な式なら関数を作る必要は無く、lambda で済ますことができる。
"""
# [Verbose] # def faster( spd ):
# [Verbose] #     return spd

str_speeds = "38 42 20 ?? 40 ?? 39" 
speeds = [ int(s) for s in str_speeds.split() if s.isdigit() ]
print(speeds) #=> [38, 42, 20, 40, 39]

# [Verbose] # speeds.sort(key=faster, reverse=False)
speeds.sort(key = lambda spd: spd, reverse = False )
print(speeds) #=> [20, 38, 39, 40, 42]

# 正の整数に対して -1 を掛けて、強引に降順ソートをする場合
speeds.sort(key = lambda spd: -spd, reverse = False )
print(speeds) #=> [42, 40, 39, 38, 20]

 

callback.py

  • Python では(?)高階関数と呼ぶらしいが、いわゆるコールバック。
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""

class CB:
    def __init__(self):
        pass

    def set_callback(self, func):
        self.fn = func

    def invoke_notify(self):
        self.notify()
        
    def notify(self):
        self.fn( "Booooooooooooom" )


def wakeup( mesg:str ):
    print("Wake Up: {0}".format(mesg))


if __name__ == '__main__':

    obj = CB()

    # コールバックを登録する
    obj.set_callback( wakeup )

    # 再度コールバックを呼び出す
    obj.invoke_notify()

format_1.py

  • フォーマットに文字列を差し込む
  • 複数を同時に差し込む
  • 数値で差し込み位置を指定する
  • オブジェクトのアトリビュートを表示する
  • キーで差し込み位置を指定する
  • 辞書で差し込み位置を指定する
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
#--------------------------------------------
# フォーマットに文字列を差し込む
#--------------------------------------------
s = "{} loves Python !".format('Guido')
print(s)    #=> Guido loves Python !

#--------------------------------------------
# 複数を同時に差し込む
#--------------------------------------------
#=> <a href="http://python.org">python.org</a>
#   <a href="http://pypy.org">pypy.org</a>
#   <a href="http://cython.org">cython.org</a>
linkstr = '<a href="{}">{}</a>'
for i in [  'http://python.org',
            'http://pypy.org',
            'http://cython.org',]:
    print( linkstr.format(i, i.replace('http://' , '')) )

#--------------------------------------------
# 数値で差し込み位置を指定する
#--------------------------------------------
s = "{0} {1} {0}".format('Spam', 'Ham')
print(s)    #=> Spam Ham Spam

#--------------------------------------------
# キーで差し込み位置を指定する
#--------------------------------------------
s = "{food1} {food2} {food1}".format(food1='Spam', food2='Ham')
print(s)    #=> Spam Ham Spam

#--------------------------------------------
# 辞書で差し込み位置を指定する
#--------------------------------------------
d = { 'name':'Guido', 'birthyear':1964 }
s = "{0[birthyear]} is {0[name]}'s birthyear.".format(d)
print(s)    #=> 1964 is Guido's birthyear.

#--------------------------------------------
# オブジェクトのアトリビュートを表示する
#--------------------------------------------
#=> Python version: 3.5.3 (default, Nov 23 2017, 11:34:05) 
#   [GCC 6.3.0 20170406]
import sys
s = "Python version: {0.version}".format(sys).replace("\n", 'v(^-^)v ')
print(s)

 

format_2.py

  • 寄せ(左、右、中央)を指定して差し込む
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
#--------------------------------------------
# 寄せを指定して差し込む
# (1つ目=桁数10、2つ目=右寄せ, 3つ目=中央で表示する)
#--------------------------------------------
#=> Spam            300
#=> Ham             200
tmpl = "{0:10} {1:>8} {2:^}"
list = []
list.append(tmpl.format('Spam', 300, 324))
list.append(tmpl.format('Ham',  200, 216))
for s in list:
    print(s)

del list[:] #=> 全要素を削除する

# ============================================
#「:」を使うことで書式制御が可能になる
# ============================================
#--------------------------------------------
# 2015年末の日本の就業人口比率(%)=(就業者数÷ 総人口(万人)× 100 
#--------------------------------------------
s = "{:.2%}".format(6381/12708) #=> 50.21% (下二桁まで表示する) 
print(s)

#--------------------------------------------
# 2015年末の日本の総人口を「,」を付与して表示する
#--------------------------------------------
s = "{:,}".format(127080000)
print(s)    #=> 127,080,000

#--------------------------------------------
# 数値に符号を付ける
#--------------------------------------------
list = [ 10, -20 ]
for i in list:
    x = "{:>+4}".format(i)  # + と - の両方、かつ、右寄せで表示する
    y = "{:>-4}".format(i)  # - のみ、かつ、右寄せで表示する
    z = "{:>-8}".format(i)  # - のみ、かつ、右寄せ8桁で表示する
    print("(x, y, z) = ({X}, {Y}, {Z})".format(X=x, Y=y, Z=z))

 

format_3.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
#--------------------------------------------
# 整数値を16進数表示する
# 
#--------------------------------------------
list = [ 1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1023, 1024 ]

for i, v in enumerate( list, start=0 ):
    print("list[{idx}] => ".format(idx=i), end=" ")
    print("0x{v:x}".format(v=v), end=", ")  # 0x4 と表示する
    print("0x{v:>04x}".format(v=v))         # 0x0004 と表示する

 

slice_1.py

  • list[ 開始 : 終点 : 加算値 ] ということ。(C言語の for と同じ)
#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
def length(data):
    print("length=>{0}".format(len(data)))

a = [1, 2, 3, 4, 5]
print(a)        #=> [1, 2, 3, 4, 5]

# a[1], a[2], a[3] を表示する
print(a[1:4])   #=> [   2, 3, 4   ]

# エラーにはならない
print(a[2:100]) #=> [      3, 4, 5]

# 2インクリメントする
print(a[::2])   #=> [1,    3,    5] 

# a[1], a[2] を入れ替える
a[2:4] = ['Three', 'Four']          
print(a)        #=> [1, 2, 'Three', 'Four', 5]
length(a)

# a[3] 以降すべての要素を削除する。配列長も 5 から 2 になる。
del a[2:]
print(a)    #=> [1, 2]
length(a)   #=> 2

 

zip.py

#!/usr/bin/env python3
# -*- coding: utf-8 -*- 
"""
みんなのPython 第4版
"""
# zip 関数は目印無しで Linux の join コマンドを使う感覚に近い

# 2つのリスト(タプル)の要素数が同じ場合
A=(  1,   2,   3,   4  )
B=( 'a', 'b', 'c', 'd' )

for a, b in zip( A, B ):
    print(a, b)

#=> 1 a
#   2 b
#   3 c
#   4 d

# 要素数が少ない方に合わせられる
X=[ 1,  2,  3,  4     ]
Y=['A','B','C','D','E']

for x, y in zip( X , Y ):
    print(x, y)
#=> 1 A
#   2 B
#   3 C
#   4 D