表の最大列を取得する関数を作成する

毎月の試算表が列ごとに記されており、新しい月の試算表は表の最大(右)列のひとつ右の列に書き込まれていきます。

では表の最大列はどのように取得したらよいのでしょうか?

通常はmax_columnで取得できますが、表からはずれて右側に文字または書式が設定されている場合、その列を最大列と認識してしまいます。

すると書き込みはその右側の列に書き込まれてしまいます。

上の図では、表の最後は先月(4月)の書き込みがされているD列なので、当月(5月)分としてはE列に書き込みたいところです。
しかし、G4にグレー色の書式が設定されているため、G列を表の最後の列と認識してしまい、その右の列、つまりH列に5月分が書き込まれてしまっています。

表からはずれて文字入力や書式が設定されていても、表の最終列を認識するためそれに対応する関数を作成することにします。

最大列を取得する関数を作る

書式が設定されていてもデータがなければ空列とみなすように作成します。

def remove_right_none(lst): # 関数名
    count = len(lst) # ①
    for item in reversed(lst): # ②
        if item.value is None: # ③
            count = count – 1 # ③
        else:   # ④
            break # ④
    return count # ④

① 引数に指定されたlstの長さをカウントする
② 最後のセルからひとつづつitem変数に入る
③ そのセルが空白ならばカウントを1つ減らず
④ セルが空白でなければ処理は終了して、その時点のセルの数を返す(それが空白列を除いた最大列となる)

 

 

最大列を取得する関数ができたところで、さっそく使用してみます。

作成した remove_right_none( ) 関数を次のように利用します。

# ワークシートの取得
ws_2 = wb[“合計残高試算表_2”]

# 各行の最大列うち、最も大きい列を取得
data_column_num_2 = max([remove_right_none(row) for row in ws_2.rows])  

1.シートの行から1行づつ取り出しrow変数へ代入する。
2.そのrow(1行分)が関数の引数となりremove_right_none( )関数で処理され列数が返る。
3.すべての行につき関数で処理された後、max( )によりその中から1番大きい列数が最大列としてdata_column_num_2へ代入される。

これで表の最大列(上記図のD列)が取得されました。

 

 

Pythonでパスワードを生成する

要件
文字や数値を入れた箱から、1つづつランダムに選び出し、それらを連結した文字列を作成する。

パスワードを生成する時などに使えます。

コード

import string
import secrets

def pass_gen(size=10):
chars = string.ascii_uppercase + string.ascii_lowercase + string.digits

return ”.join(secrets.choice(chars) for x in range(size))

print(pass_gen(6))

GAQK0FUENn

 

手順

1.chars変数に、パスワードで使用する文字・数字を代入します。

2.そのchars変数からひとつづつ文字・数値をランダムに抽出します。

3.抽出された文字・数値を結合してパスワードが出来上がります。

 

 

説明

1.chars変数に代入する文字・数値について

 ① string.ascii_uppercase
       大文字 ‘ABCDEFGHIJKLMNOPQRSTUVWXYZ’

    ② string.ascii_lowercase
       小文字 ‘abcdefghijklmnopqrstuvwxyz’

    ③ string.digits
       文字列 ‘0123456789’

    ほか
 記号を入れる場合は ’%&$#’ 
 ①と②を合わせたものは string.ascii_letters

 

2.パスワードの文字数について

print(pass_gen(6))
pass_gen( )の中にパスワードの文字数を指定します。
ここでは6つの文字数を指定しています。
数値を指定せずに、print (pass_gen( ) ) とすると、10の文字数のパスワードが出来上がります。
これは最初に、
def pass_gen(size=10):の箇所で
デフォルト値をsize=10としているためです。

 

3.文字の抽出および結合について

secrets.choice(chars) for x in range(size)で文字を抽出しています。
これを ”.join( ) の( )の中に入れることにより、ひとつづつ抽出された文字・数値が結合されます。

”.join( ) の 「” 」はシングルクォーテーションが2つで、文字を連結したい記号を中に入れます。
ここでは、文字を空白で連結したいので”としています。
(” はシングルクォーテーションが2つです)

もしもハイフン(‐)で結合する場合には”の間に「‐」を入れ
‘‐’.join(  ) とします。

カンマ(,)で文字を結合する場合には、”の間に「,」を入れ
‘,’.join(  )とします。

 

パスワードが生成されるイメージ

 

注意

secretsモジュールについて

先のコードでは、乱数を生成するのにsecretsモジュールを使用しています。
乱数を生成するにはrandomモジュールでも生成できますが、あくまでもシミュレーション向けの擬似乱数で,セキュリティや暗号学的に設計されていないようです。

セキュリティ向けの強い乱数を生成できるsecretsモジュールを用いるので、Python3.6以上を利用してください。

IDLEを利用する場合について

先のコードをIDLEのshell画面にコピペすると、次のエラーが出ます。

SyntaxError: multiple statements found while compiling a single statement

IDLEのShell画面では複数行に渡るペーストはできないようです。
複数行のペーストをする場合には、Shell画面のFile>New Fileで出てくる「エディター画面」の方を利用して下さい。

こちらはエディターで、Run>Run Moduleとしてみてください。
実行結果がShell画面の方へ出力されます。

jupyter notebookであればそのままコピペしても大丈夫です。
というより、IDLEのShell画面のみコピペ不可のようです。

数値の処理方法 – 桁区切り / format関数 / python

桁の大きな数字を記載する時には、3桁ごとにカンマで区切るのがマナーです。

いくら数字に慣れている人でも、「100000000」をすぐに1億だと判断できる人はいないと思います。

この3桁区切りは、特に英語では理解が簡単です。

英語では、1(one) ,  10(ten) ,  100(hundred)  の後は次のように3桁ごとに単位が用意されています。

1,000=thousand
1,000,000=million
1,000,000,000=billion
1,000,000,000,000=trillion

このように区切りがあることにより、大きな数字でも簡単に読むことができます。

5,000は、5と1,000(thousand)だから「five thousand」
50,000は、50と1,000(thousand)だから「fifty thousand」
500,000は、500と1,000(thousand)だから「five hundred thousand」

5,000,000 は、5と1,000,000(million)だから「five million」
50,000,000は、50と1,000,000(million)だから「fifty million」
500,000,000は、500と1,000,000(million)だから「five hundred million」

というように、以下billion, trillion も
50,000,000,000は、50と1,000,000,000(billion)だから「fifty billion」
50,000,000,000,000は、50と1,000,000,000,000(trillion)だから「fifty trillion」

とすぐに読むことができます。

というわけで、pythonで数字に桁区切りする方法を記述します。

桁区切りなし

ave_v=766666
print(ave_v)
>>> 766666

「ave_v」は変数で、数値が代入されています。

 

桁区切りあり

ave_v=766666
print( ” {:,} ” . format(ave_v) )
>>> 766,666

桁区切りをつけるには、
 ” {:,} ” . format(     ) 
とします。

format(   ) に数値または数値が代入されている変数を入れます。

それをprint(   )  で囲むと
>>> 766,666 と表示されます。
 

文字を付加する

ave_v=766666
print(“売上合計は”+”{:,}”.format(ave_v) + “円です”)
>>> 売上合計は766,666円です

文字を不可して表示させるには、
文字を「 ”   ”  」で囲んで、「+」でつなげます。

“売上合計は”  + ” {:,} ” . format(     ) + ” 円です”   
とします。

format(   ) に数値または数値が代入されている変数を入れます。

それをprint(   )  で囲むと
>>> 売上合計は766,666 円です
と表示されます。
 

桁区切りと小数点以下を表示する

ave_v=766666.66666
print(“売上合計は”+”{:,.2f}”.format(ave_v) + “円です”)
>>> 売上合計は766,666.67円です

 

小数点がある場合、
たとえば小数第2位まで表示させる場合は、波カッコの中を {:,.2f} とします。

小数第3位まで表示させる場合は、{:,.3f} とします。

{ コロン(:)  カンマ(,) ピリオド(.)  小数点桁数 f  } となります。


 

小数点を正しく十進法で表示する方法 – decimal / python

小数点以下を四捨五入する場合、次のように思わぬ答えが返る場合があります。


ave_v = round (1.25,1)
print(ave_v)
>>>1.2  ← 1.3のはずが・・

ave_v = round (1.35,1)
print(ave_v)
>>>1.4 ← 合ってる

 

ave_v = round (1.45,1)
print(ave_v)
>>>1.4 ← 1.5 のはずが・・

 

私たちが使い慣れているのは10進数での数値表現ですが、コンピュータは2進数で数値を表現します。
10進数と2進数の間の変換には誤差が伴います。

 

ひとつの誤差は小さいものでも、計算の過程で蓄積されていくと、最後には大きな差になる可能性もあります。

また、if により条件分岐させる場合、
AとBが一致するはずが、不一致とされて異なる処理になってしまう可能性もあります。

A = 0.1
B = 0.2
C = 0.3

if A+B==C:
    print(‘OK’)
else:
    print(‘NO’)
>>> NO  ← OK のはずなのに・・

 

これは「A+B」で返る値が微小に異なるからです。

A = 0.1
B = 0.2
print(A+B)
>>> 0.30000000000000004

 

財務においては、数値は正確に算出しなければなりません。
Pythonでは浮動小数点数の値を正確に計算することができるdecimalモジュールが用意されていますので、こちらを利用する必要があります。

 

 

十進法で正確に計算する
from decimal import Decimal

A = Decimal(“0.1”)
B = Decimal(“0.2”)

print(A + B)

>>> 0.3

 

解説

import 文によりDecimal モジュールをインポートします。

「import  decimal 」
とだけで記述してもよいのですが、その場合には

A= decimal. Decimal (“0.1”)
のように、「decimal. Decimal」と記述する必要があります。

 

Decimal ( ) には数値が入りますが、「”  ” 」または「’   ‘ 」を付けて文字列とする必要があります。
Decimal(“0.1”)の代わりに、Decimal( str(0.1) ) としてもOKです。

 

文字列としなかった場合、エラーが出てくれれば間違いに気づきますが、
次のようにエラーが出ずに誤差が出てしまうので注意が必要です。

A = Decimal(0.1)
B = Decimal(0.2)
print(A + B)
>>> 0.3000000000000000166533453694


 

任意の桁で四捨五入する

from decimal import Decimal, ROUND_HALF_UP

A=Decimal(“1.456”).quantize(Decimal(“0”),rounding=ROUND_HALF_UP)
print(A)
>>>1

B=Decimal(“1.456”).quantize(Decimal(“0.1”),rounding=ROUND_HALF_UP)
print(B)
>>>1.5


C=Decimal(“1.456”).quantize(Decimal(“0.01”),rounding=ROUND_HALF_UP)
print(C)
>>>1.46



 

解説

四捨五入する場合には、
decimalモジュールの「quantizeメソッド」を使用することで、小数点を指定した桁数で丸めることができます。

 

from decimal import Decimal, ROUND_HALF_UP
モジュールをインポートします。

 

Decimal(“  ”).
対象となる値を入力します。

 

quantize(Decimal(“ ”)
整数で丸める場合には、quantize(Decimal(“0”)とします。
小数点第1位まで求める場合には、quantize(Decimal(“0.1”)とします。
小数点第2位まで求める場合には、quantize(Decimal(“0.01”)とします。

 

rounding=ROUND_HALF_UP
引数roundingにROUND_HALF_UPを指定することで繰り上げによる四捨五入を行うことができます。

 

小数点を処理する方法 – round / python

python における小数点の処理の仕方について見ていきます。

前回はA事業に所属するチームの平均売上高を算出しました。
参照  →  売上データを集計する方法 – 辞書型 / for 構文

何のことわりもなく、四捨五入をして少数第1位まで表示させましたが、業績評価においては「四捨五入・切り捨て・切上げ」のルール通りに報告する必要があります。

前回において、平均点の計算式は
ave_v  = round (Asum/len(salesA),1) となっておりましたが、
 Asum / len (salesA) の答えを、「766666.66666」に読み替えて説明していきます。

小数点以下の処理方法

#四捨五入をする場合・・①

ave_v = round ( 766666.66666)
print(ave_v)
>>> 766667

 

#小数点以下を切り捨てる場合・・②

import math

ave_v= math.floor(766666.66666)
print(ave_v)
>>> 766666

 

#小数点以下を切り上げる場合・・③

import math

ave_v= math.ceil(766666.66666)
print(ave_v)
>>> 766667

 

① 小数点以下を四捨五入をする

小数点以下を四捨五入するには「round ( ) 」を利用します。

 

カッコ( ) の中に入れる値を「引数」といいます。
引数を複数入力できる場合は、左から第1数、第2引数と数えます。

 

round( ) の()の中の第1引数は対象となる値ですが、第2引数は丸めて表示する位を指定します。

 

第2引数を指定しない場合は小数点第1位を四捨五入して整数になります。

ave_v = round ( 766666.66666)
print(ave_v)
>>> 766667

round( 対象値 , 丸めて表示する位)

 

第2引数に「1」を指定した場合には、四捨五入をして少数点第1位まで表示します。
(小数点以下第2位を四捨五入して第1位まで表示する)

ave_v = round ( 766666.66666,1)
print(ave_v)
>>> 766666.7

 

第2引数に「-1」を指定した場合には、四捨五入をして整数1の位が「0」になります。
(整数の1の位を四捨五入する)

ave_v = round ( 766666.66666,-1)
print(ave_v)
>>> 766670.0

 

 

②小数点以下を切り捨てる

Pythonで切り捨てにするには、Python付属のmathモジュールの「floor」を使います。
「import math」と記述して、mathモジュールをインポートします。

import math
ave_v= math.floor(766666.66666)
print(ave_v)
>>> 766666

 

 

③小数点以下を切り上げる

Pythonで切り上げにするには、Python付属のmathモジュールの「ceil」を使います。
「import math」と記述して、mathモジュールをインポートします。
(すでにインポートされている場合は不要)

import math

ave_v= math.ceil(766666.66666)
print(ave_v)
>>> 766667

 

round( )で「5」を丸める場合は注意!

#期待値1.3  ×
ave_v = round (1.25,1)
print(ave_v)
>>>1.2

#期待値1.4  〇
ave_v = round (1.35,1)
print(ave_v)
>>>1.4

 

#期待値1.5 ×
ave_v = round (1.45,1)
print(ave_v)
>>>1.4

 

#期待値1.6  〇
ave_v = round (1.55,1)
print(ave_v)
>>>1.6

 

#期待値1.7   ×
ave_v = round (1.65,1)
print(ave_v)
>>>1.6

 

#期待値1.8  〇
ave_v = round (1.75,1)
print(ave_v)
>>>1.8

 

#期待値1.9   〇
ave_v = round (1.85,1)
print(ave_v)
>>>1.9

 

#期待値2.0   ×
ave_v = round (1.95,1)
print(ave_v)
>>>1.9

 

round( ) で「5」を丸める場合は注意が必要です。
上記のように例をあげてみました。

# 期待する値  〇(表示の値が同じ場合)  ×(表示の値が異なる場合)

#期待値1.3  ×
ave_v = round (1.25,1)
print(ave_v)
>>>1.2

「1.25」の値について、少数点2位を四捨五入して小数点1位で表示させています。
期待する値は「1.3」になるはずですが、表示される値は「1.2」となります。

原因は ,次の公式ページにもあるように、小数を浮動小数点数で正確に表せないことが原因 のようです。
組み込み関数round()

そこで、小数点数を正しく十進数で計算するにはdecimalモジュールを使用する必要があります。

売上データを集計する方法 – 辞書型 / for 構文

財務部では毎月業績を算出し、分析をして経営会議へ報告する必要があります。データの取得から分析、ひいては報告資料まで自動化したいものです。

pythonは分析系に強いプログラミング言語ですので、財務に携わる方はぜひ習得しておきましょう。

まずは簡単なところから始めるにあたり、チームの売上高を合計し、平均を算出するところからやってみたいと思います。

要件
チームの平均売上高を求めたい

 

次のような設定を想定します。

事業Aに、チームが3チーム(A,B,C) 所属しています。
それぞれのチームの月間売上高は次の通りでした。

事業名:A_bu
所属チーム 売上高 
Aチーム   60万円
Bチーム   80万円
Cチーム   90万円
合計     230万円

この3チームの平均を求めていきます。

230万円÷3=76.6万円になれば正解ですね。

要件回答
売上合計: 2300000
平均点: 766666.7

 

チーム売上の平均を求める

#A事業の業績データを辞書型で集計する・・①
salesA={‘A’:600000,’B’:800000,’C’:900000}
#合計を求める
Asum = 0
for v in salesA.values():
    Asum += v
print(‘売上合計:’,Asum)


”’チーム当たりの平均売上高を計算・・②
小数点以下1位になるように四捨五入”’

ave_v=round(Asum/len(salesA),1)
print(‘平均点:’,ave_v)

 

 

①A事業の業績データを辞書型で集計する

salesA={‘A’:600000,’B’:800000,’C’:900000}

変数「salesA」={ キー(チーム名):値(売上高)}
として辞書型でセッティングします。

#合計を求める
Asum = 0
for v in salesA.values():
Asum += v

平均を求めるには、まず合計を求める必要があります。
「Asum」という箱を設けて、ここに各チームの売上高を放り込んでいきます。

最初はAsumの箱は何も値が入らない「0」を設定します。
for 構文を使ってひとつづつデータを取り出し、Asumに加えていきます。

for構文は次のようになります。

「salesA」は①で設定した辞書型の変数で、チームと売上高が格納されています。
「values()」でそのデータから「値」を取り出します。ここでの値は「売上高」ですので、各チームの売上高がfor の後の「v」へ順番に入っていきます。

辞書型データは {‘A’:600000,’B’:800000,’C’:900000} となっていますので、
まずは’A’チームの「600000」が「v」に入ります。

そして、その「v」の値が
Asum+=v でAsumの箱に放り込まれます。
「Asum+=v 」は 「Asum  =  Asum + v  」と同じ意味です。

これでAsumの箱は「600000」が入ることになります。

次に、’B’チームの「800000」が「v」に入り、それが「Asum」に追加されます。そして’C’チームの売上高がAsumへ加算された時点でfor ループは終了します。

print(Asum)で合計を表示させると
>>>  2300000
となっていれば正解です。

 

②チーム当たりの平均売上高を計算

ave_v=round(Asum/len(salesA),1)
print(‘平均点:’,ave_v)

 

最初の行で平均を算出して、その値を「ave_v」変数へ代入しています。
Asum  /  len(salesA)  は 
合計   /     チーム数    を意味しています。

Asum は ①より求めた売上高の合計(2300000)が格納されています。len(salesA) は  ①の冒頭で設定したsalesAに格納されている値の数(3)となります。

print(ave_v)で
>>> 766666.7
と表示されれば正解です。

 

辞書型からデータを抽出する基本的な使い方- for 構文 / python

pytonにおいて、データを1つの変数に格納する方法はコレクションとよばれ、大きく分けて4つの方法があります。

1.リスト型
2.ディクショナリ型
3.タプル型
4.集合型

詳しくはこちらを参照→ 複数データを1つの変数で管理する / コレクション

 

辞書型では、「キー」と「値」をセットで格納することができ、「キー」を指定して「値」を呼び出すことができます。

今回は、辞書型のコレクションから、キーと値を同時に取り出して、セットで画面表示する方法について記述しておきます。

 

要件
事業Aで扱う商品を販売価格とセットで表示させたい

 

当社のA事業で扱う商品と販売単価の一覧は次の通りです。

商品名  販売単価
a                   1,000
b                   3,000
c                   5,000
d                   7,000
g                   9,000

商品データが辞書型で変数に代入されています。
Aitem={ ‘a’:1000,’b’:3000, ‘c’:5000, ‘d’:7000, ‘g’:9000}

 

要件回答
aの販売単価は1000円です。
bの販売単価は3000円です。
cの販売単価は5000円です。
dの販売単価は7000円です。
gの販売単価は9000円です。

 

コード(D-1)

#辞書型のデータ(商品名と販売単価)を変数に代入・・①
Aitem={
    ‘a’:1000,
    ‘b’:3000,
    ‘c’:5000,
    ‘d’:7000,
    ‘g’:9000
}

#辞書型のデータ一からキーと値をセットで取得する・・②
for name,price in Aitem.items():

#画面に出力・・③
    sp=”{0}の販売価格は{1}円です。”.format(name,price)
    print(sp)

>>>
aの販売価格は1000円です。
bの販売価格は3000円です。
cの販売価格は5000円です。
dの販売価格は7000円です。
gの販売価格は9000円です。

 

 

 

①辞書型のデータ(商品名と販売価格)を変数に代入する

変数名を「Aitem」とし、次のようにセットします。
辞書型は波カッコ{ } で括ります。

Aitem={ ‘a’:1000,’b’:3000, ‘c’:5000, ‘d’:7000, ‘g’:9000}

変数名 =  {商品名1:販売価格1, 商品名2:販売価格2・・・}

 

②辞書型のデータからキーと値をセットで取得する

for name,price in Aitem.items():

構文は、
for 「キー変数」, 「値変数」 in  「辞書型変数」. items( ) :
items( ) は、キーと値を利用する関数です。

 

Aitem に格納されているキー(商品名)と値(販売単価)が順番にfor 以下の「キー変数 name」と「値変数 price」の箇所に入っていきます。

まず最初の処理「’a:1000’」から処理が始まります。
「a」が「name」に入り、「1000」が「price」に入ります。

 

③画面に出力する

  sp=”{0}の販売価格は{1}円です。”.format(name,price)

 

まず、画面表示として表示したい文字列を for 構文の変数で設定した「name」と「price」をブランクにして作ります。

” { } の販売単価は { } 円です。”

と、値を埋め込みたい場所に{ } を書きます。

最初の{ } に「0 」と番号を付け、次の{ } には「1」と番号を付けていきます。

 

format( name, price )のうち、「name」が {0} に入り、priceが{ 1 } に入ります。

今、「name」には「a 」が入っており、「price」には「1000」が入っているので、{0} には「a」が入り、{1}には「1000」が入ることになります。

よって、
“{0}の販売価格は{1}円です。” →  ”{a}の販売価格は{1000}円です。”
となります。

spはその文字列が入る変数で、print(sp)で表示させます。

 


f-stringという機能を使用すると、簡潔に書くこともできます。

sp= “{0}の販売価格は{1}円です。”.format(name,price)
print(sp)

の代わりに

print ( f  ” 商品 {name} の販売価格は {price} 円 です”  )

と記述します。

文字列の直前に「f」を付けると、数値が格納された変数名を{ } の中に直接入れることができますので、こちらの方がわかりやすいかもしれません。


 

一つ目の処理が終了すると、二つ目の処理に移りますので、

Aitem に格納されている2つ目の商品と販売価格のセット「b: 3000」の処理が始まります。

同じような処理を繰り返し、最後の商品まで終了したらプログラムは終了します。

 

分析に役立つ集合演算の作り方 / python

当社は、A事業とB事業に分かれており、A事業で扱う商品とB事業で扱う商品が区分されています。

次のような質問に答えるためどのようにデータを抽出するかを記述しておきます。

①A事業とB事業を合わせた全体の商品一覧

②A事業のうちB事業で扱っていない商品一覧

③B事業のうちA事業で扱っていない商品一覧

④A事業とB事業の両方で扱っている商品一覧

⑤A事業とB事業でだぶっていない商品一覧

 

コードの説明に入る前に集合演算についておさらいをしてみます。
2つのセットの共通点や相違点を探すには、「集合演算」の考え方を利用します。
学生の頃ベン図を学んだかと思いますが、関係性をベン図で描いてみます。

 

a商品~g商品まで7つの商品があります。
A事業とB事業でそれぞれ次のように商品を扱っています。

A事業:a,b,c,d,g
B事業:b,c,d,e,f

 

 

和集合
二つの集合に対して、少なくともどちらかに入っているものを集めた集合を和集合といいます。

差集合
ある集合の要素から別の集合の要素を取り除いたものを差集合といいます。

積集合
二つの集合に対して、両方とも入っているものを集めた集合を積集合といいます。

対称差
二つの集合に対して、どちらか一方だけを満たす要素を集めた集合を対称差といいます。

課題の①~⑤のうち、それぞれがどの集合に相当するのかを当てはめてみます。

①A事業とB事業を合わせた全体の商品一覧・・和集合

②A事業のうちB事業で扱っていない商品一覧・・差集合

③B事業のうちA事業で扱っていない商品一覧・・差集合

④A事業とB事業の両方で扱っている商品一覧・・積集合

⑤A事業とB事業でだぶっていない商品一覧・・対称差

 

それでは、イメージ図ができたところでコードの記述をしていきます。

 

集合演算の作り方

#商品を変数にセットする
itemA={‘a’,’b’,’c’,’d’,’g’}
itemB={‘b’,’c’,’d’,’e’,’f’}

#A事業とB事業を合わせた全体の商品一覧を作る・・①
itemA|itemB
>>> {‘a’, ‘b’, ‘c’, ‘d’, ‘e’, ‘f’, ‘g’}

#A事業のうちB事業で扱っていない商品一覧を作る・・②
itemA-itemB
>>> {‘a’, ‘g’}

#B事業のうちA事業で扱っていない商品一覧を作る・・差集合・・③
itemB-itemA
>>> {‘e’, ‘f’}

#A事業とB事業の両方で扱っている商品一覧を作る・・④
itemA&itemB
>>> {‘b’, ‘c’, ‘d’}

#A事業とB事業でだぶっていない商品一覧を作る・・⑤
itemA^itemB
>>> {‘a’, ‘e’, ‘f’, ‘g’}


 

 

集合と演算子の関係は次の通りです。

課題番号 集合の種類 コード記述の演算子
和集合 「|」
②③ 差集合 「− 」
積集合 「&」
対称差 「^」

 

 

コレクションを2次元で管理する / python

会社にはいくつか異なる事業があり、データ整理も複雑になってきます。

当社には、いくつかの事業がありますが、
まずは簡単に2つの事業があるものとし、それぞれの事業にいくつかのチームがぶらさがっている系統図でデータ管理方法をまとめておきます。

 

イメージ図

 

 

2次元リストの作成

#リストを作成する・・①

A_bu=[‘A’,’B’,’C’]
B_bu=[‘D’,’E’,’F’]
com=[A_bu,B_bu]

#全チームのリストを抽出する・・②
print(com)
>>> [[‘A’, ‘B’, ‘C’], [‘D’, ‘E’, ‘F’]]

 

#A事業のリストを抽出する・・③
print(com[0])
>>> [‘A’, ‘B’, ‘C’]

 

#B事業のうち、インデックス番号2番目のチームを抽出する・・④
print(com[1][2])
>>> F

 

説明
①~④の番号は上の番号を参照しています。

 

①リストを作成します。

A事業には
Aチーム、Bチーム、Cチームが所属しており、変数「A_bu」に格納します。

B事業には
Dチーム、Eチーム、Fチームが所属しており、変数「B_bu」に格納します。

会社全体では
A事業(A_bu) とB事業(B_bu)があり、変数「com」に格納します。
ここが2次リストとなっており、
com[ ] のリストの中に、A_bu[ ] のリストとB_bu[ ] のリストが格納されている状態となります。

リストの中に、リストがあるってことですね。

②全チームのリストを抽出しています。

変数comは会社全体の変数ですので、A事業、B事業あわせた全チームが抽出されます。

 

③A事業のリストを抽出します。

変数com は、①で com=[A_bu,B_bu]と定義しました。

com リストのインデックス番号として、A_bu が「0」、B_buが「1」となりますので、com[0]は A_buを意味し、A_buのリストが表示されます。

 

④B事業からチームを抽出します。

com[1][2]のうち、最初の引数[1]はB_bu を意味し、次の引数[2] は2番目のインデックス番号を意味します。

よって、B事業のリストからインデックス番号2番である3番目の要素「F」が抽出されます。

インデックス番号は「0」から始まりますので、
インデックス番号2番は、要素でいう左から3番目となります。

要素       D E  F
インデックス  0 1 2 

 

 

複数データを1つの変数で管理する – コレクション / python

財務など分析系にはpythonというプログラミング言語が最適です。pythonを利用して業務効率を図るにはどうすればよいかを考えていきます。

データ処理をするにあたり、リストの使い方を学ぶ必要がありますので、まずリストの作り方、使い方についてまとめていきたいと思います。

得意先のデータを使って分析したいとき、得意先ごとに変数を利用していると、変数がいくつあっても足りません。

データをリストにして1つの変数にまとめましょう。

 

  [リストの作成]

リストの作り方
#得意先リストの作成
tokuisaki=[‘A’,’B’,’C’,’D’,’E’,’F’,’G’]

「リスト」を作るには、角括弧 [ ] の中にコンマ , で区切って複数のデータを記述します。

A社からG社を「tokuisaki」という1つの変数で管理します。
tokuisaki=[ ]  が得意先リストになり、[ ] の中に得意先の社名を記述します。

print(tokuisaki)で確認すると、
>>>[‘A’,’B’,’C’,’D’,’E’,’F’,’G’]
と表示されtokuisaki変数にA社からG社まで格納されていることが確認できます。

リストに含まれるデータのことを「要素」といいますが、この例では要素が会社名ですので、文字列として記述されています。
文字列で記述するときには、’A’ のように「 ’ 」で囲みます。

文字を囲む「’ 」や、文字を区切る「, 」は半角で入力することに注意して下さい。

 

リストを追加する

#得意先リスト
tokuisaki=[‘A’,’B’,’C’,’D’,’E’,’F’,’G’]

#得意先を追加する
tokuisaki.append(‘H’)
tokuisaki.append(‘I’)

>>>[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’] 

 

すでに  tokuisaki=[ ] という得意先リストがあり、そのリストに新たに得意先を追加します。

リストにデータを追加するときには、append( ) を利用します。
append( ) の( )の中に追加したい得意先名を入力します。
ここでは、H社とI社の2社をリストに追加しています。

print(tokuisaki)で確認すると、
>>>[‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’] 
と表示され、リストに ‘H’ と ‘I’ が追加されていることが確認できます。

 

リストを数える

#得意先リスト
tokuisaki=[‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’]

#得意先数を数える
len(tokuisaki)

>>>9

 

tokuisaki=[ ] のリストにA~Iまでの会社がセットされていますが、この会社数を数えたいと思います。
リストの要素数を数えるにはlen( )関数を利用します。

len( )の( )に変数名を入れてlen ( tokuisaki) とすると
>>>9
となり9社あることが確認できます。

 

インデックス番号を確認する

#得意先リスト
tokuisaki=[‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’]

#得意先ごとインデックス番号を確認する
for i,v in enumerate(tokuisaki):
    print(i,v)

 

tokuisaki=[ ] のリストの中にはA~Iまで9社のデータが格納されています。

リストの要素は1番目の要素を0として順番に番号が付けられており、この番号をインデックスといいます。

上のコードでは for 構文を利用してA~Iのそれぞれの得意先のインデックスを確認しており、次のように返ってきます。

 

0 A
1 B
2 C
3 D
4 E
5 F
6 G
7 H
8 I

 

得意先を呼び出す

#得意先リスト
tokuisaki=[‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’]

#得意先リストのうち4番目(0始まり)を表示
tokuisaki[4]
>>> ‘E’

#得意先リストのうち4番目(0始まり)未満を表示
tokuisaki [:4]
>>> [‘A’, ‘B’, ‘C’, ‘D’]

#得意先リストのうち5番目(0始まり)以降を表示
tokuisaki[4:]
>>> [‘E’, ‘F’, ‘G’, ‘H’, ‘I’]

 

それぞれの会社のインデックス番号がわかりました。

tokuisakiリストの中から会社を呼び出したいと思います。

呼び出すときには、変数[インデックス番号]で呼び出します。
インデックスは「0」から始まるので注意が必要です。


Eを呼び出すときには tokuisaki[4] と記述します。

[ ] に0を指定すると、1番目の要素が呼び出され、
[ ]に4を指定すると、5番目の要素が呼び出されます。

 

[ : 4 ]とするとインデックスの4番目未満の値が呼び出されます。
インデックスの4番目は要素の5番目であり、「E」にあたります。

「E」未満の値が返りますので、
 >>> [‘A’, ‘B’, ‘C’, ‘D’] となります。

 

[ 4 :]とするとインデックスの4番目以上の値が呼び出されます。
インデックスの4番目は要素の5番目であり、「E」にあたります。

「E」以上の値が返りますので、
 >>> [‘E’, ‘F’, ‘G’, ‘H’, ‘I’] となります。

 

インデックス番号はあくまでも現在リストにある要素の連番ですので、ある要素(データ)が削除されるとそれ以降のインデックス番号は変わってしまいます。

インデックス番号は得意先番号には利用できません。

 

 

 

  {辞書型の作成}

得意先をコードで管理する

#得意先に得意先コードを付ける

tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’}

#得意先を呼び出す
tokuisaki[‘2-1’]

>>> D

 

インデックス番号は、0から始まる連番ですので要素が削除されると得意先に付されていた番号が変わってしまいます。

得意先ごとに得意先コードをセットするには「辞書型」を利用します。

変数={ キー1:値1, キー2:値2・・}
というように呼び出すキーと値をセットにして、波括弧{ } で括ります。

 

得意先A~Iに次のようにコードを決め、
tokuisaki={‘得意先コードA’ : ‘社名A’ , ‘得意先コードB’ : ‘社名B’ , ・・・}
のようにセットしていきます。

 

得意先コード  得意先名
1-1                            A
1-2                            B
1-3                            C
2-1                            D
2-2                            E
2-3                            F
3-1                            G     
3-2                            H
3-3                             I

 

tokuisaki [‘2-1’]  とすると「D」が呼び出されます。

 

新規得意先が既に登録されているか確認する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’}

#得意先一覧を作成する・・①
tokuisaki.values

>>> dict_values([‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’])

#得意先一覧から得意先Jが存在するか確認する・・②

if ‘J’ in tokuisaki.values():
    print(‘exists’)
else:
    print(‘not’)

>>> not

 

得意先J社が新たに増えました。

新規得意先 ‘J’ を辞書型に登録したいのですが、既に登録している可能性もあります。
新規得意先「J」がデータに存在するか確認をしていきます。

 

① まず、得意先一覧からコードを除いた得意先名のみの一覧を作成します。

「変数.values」で辞書型データから値のみ抽出した一覧が作成できますので、「 tokuisaki.values( ) 」と記述すると次のように値(取引先名)のみの一覧が取得できます。
>>> dict_values([‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’])

 

② 次に、このデータ一覧(tokuisaki.values) から新規得意先「J」が存在するかどうかをif文を使って検索していきます。

「J」はまだデータに存在していないので、「not」が返りました。

 

得意先コードが存在しているか確認する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’}

#得意先コードが使用されているか確認する
‘3-4’ in tokuisaki

>>>False

 

新規得意先「J」はまだ登録されていないことが確認できました。

「J」の得意先コードを「3-4」としたいのですが、コードが重複することはできませんので、現在使用されているか確認の必要があります。

辞書型のリストの中に、’キー’ が存在しているかは「 ‘ キー’  in 変数 」で確認できます。

‘キー’を「3-4」とし、変数を「tokuisaki」として
「’3-4′ in tokuisaki」と記述すると

>>>False
と返答がありましたので現在利用されていないことがわかりました。
(既に使用されている場合は  True が返ります)

 

新規得意先を追加する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’}

#新規得意先データを追加する
tokuisaki[‘3-4′]=’J’

 

新規得意先「J」はまだ登録されていないことが確認できました。
それでは、「J」社のコードを「3-4」として得意先データに追加していきます。

指定したキーが辞書内の要素にすでに使用されている場合は、変更になってしまい元のデータが消えてしまいますので注意が必要です。
(変更も追加も同じ構文のため)

print(tokuisaki) で次のように表示され、’3-4′ : ‘J’ が追加されていることが確認できました。

>>> {‘1-1’: ‘A’, ‘1-2’: ‘B’, ‘1-3’: ‘C’, ‘2-1’: ‘D’, ‘2-2’: ‘E’, ‘2-3’: ‘F’, ‘3-1’: ‘G’, ‘3-2’: ‘H’, ‘3-3’: ‘I’, ‘3-4’: ‘J’}

 

得意先コード一覧を表示する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’,’3-4′:’J’}

#得意先コードの一覧を表示する
tokuisaki.keys()

>>> dict_keys ([‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’])

 

得意先J社が新たに加わり、得意先コード「3-4」としました。

では、現在利用されている得意先コードのみを列挙してみます。
辞書の ‘キー’ を列挙するには、「keys( ) 」を利用します。

「変数.keys( ) 」と打ち込むと辞書型で利用している’ キー’ が列挙されます。

変数は「tokuisaki」ですので 「 tokuisaki.keys( ) 」と記述します。

すると次のように辞書の ‘キー’ である得意先コードの一覧が列挙されます。

>>> dict_keys([‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’])

 

さきほど追加した「3-4」が加わっていることが確認できます。

 

型をリスト型に変換する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’,’3-4′:’J’}

#辞書型をリスト型に変換する

 list ( tokuisaki.keys() ) 

>>> [‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’]

 

さきほど列挙した得意先コードは「dict_keys」という辞書型の型になっています。
>>> dict_keys ([‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’])

 

これを使いやすいリスト型に変換します。

辞書型で列挙した「tokuisaki.keys( )」の記述を「list( )」で括って次のようにします。
list( tokuisaki.keys( ) )

 

リスト型に変換できました。
>>> [‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’]

 

コードと社名の組み合わせ一覧を表示する

#得意先リスト
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’,’3-4′:’J’}

#得意先コードと得意先名の組み合わせ一覧

list( tokuisaki.items() )

>>>
[(‘1-1’, ‘A’),
(‘1-2’, ‘B’),
(‘1-3’, ‘C’),
(‘2-1’, ‘D’),
(‘2-2’, ‘E’),
(‘2-3’, ‘F’),
(‘3-1’, ‘G’),
(‘3-2’, ‘H’),
(‘3-3’, ‘I’),
(‘3-4’, ‘J’)]

 

さきほどは得意先コードのみ列挙しましたが、ここで得意先コードと会社名をセットにして列挙してみたいと思います。

「items( )」メソッドを利用して list( 変数.items( ) )
と記述すると、’キー’ と ‘値’ を組み合わせにしたリストを得ることができます。

変数は「tokuisaki」ですので list( tokuisaki.items() )として記述しています。

 

  (タプル型の作成)

リスト型、辞書型で作成したデータは追加、書き換えが可能です。

データを書き換えることができるということは、書き換えられてしまうということでもあります。

業務で使用するには、うっかりデータを削除してしまったり、書き換えてしまったりすることがないようにしたいものです。

その場合には、「タプル型」でデータを作成します。

タプルは丸カッコ( ) で定義します。
(リストはカギカッコ[ ] , 辞書型は波カッコ{ }でした。)

タプルは要素の追加、変更、削除ができません。

 

辞書型をタプルに変換する

#辞書型データ
tokuisaki={‘1-1′:’A’, ‘1-2′:’B’, ‘1-3′:’C’, ‘2-1′:’D’, ‘2-2′:’E’, ‘2-3′:’F’,’3-1′:’G’,’3-2′:’H’,’3-3′:’I’,’3-4′:’J’}

#辞書型をタプル型に変換・・①

tp_tot=tuple(tokuisaki.items())

#辞書型のキー(得意先コード)をタプル型に変換・・②
tp_key=tuple(tokuisaki)

#辞書型の値(会社名)をタプル型に変換・・③
tp_value=tuple(tokuisaki.values())

 

①辞書型のデータを、キーと値をセットにしたままタプルに変換します。

print(tp_tot) で次のように表示されます。

>>> ((‘1-1’, ‘A’), (‘1-2’, ‘B’), (‘1-3’, ‘C’), (‘2-1’, ‘D’), (‘2-2’, ‘E’), (‘2-3’, ‘F’), (‘3-1’, ‘G’), (‘3-2’, ‘H’), (‘3-3’, ‘I’), (‘3-4’, ‘J’))

 

②辞書型のデータのうち、キーのみをタプルにするには
tuple(変数)で変換できます。

キーである得意先コードをタプルにして、変数  tp_key  に格納します。
tp_key=tuple(tokuisaki)

print(tp_key) で次のように表示されます。

>>> (‘1-1’, ‘1-2’, ‘1-3’, ‘2-1’, ‘2-2’, ‘2-3’, ‘3-1’, ‘3-2’, ‘3-3’, ‘3-4’)

 

③辞書型のデータのうち、値データのみをタプルにするには
 まず「変数.values()」で辞書型データから値のみを抜き出します。
 それをtupule() で囲み tuple( 変数.values() ) となります。

値である得意先名をタプルにして、変数 tp_value に格納します。
tp_value=tuple( tokuisaki.values() )

print(tp_value)で次のように表示されます。

>>> (‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’, ‘J’)

 

  {集合型の作成}

 

集合型は辞書型と同じく波カッコ{ }で括ります。
(辞書型のようにキーはありません)

集合型は重複する値を持たせることはできず、順序も意図的に付けられません。

その代わり、結合したり、差を求めたり、同一データを抽出したりすることができます。

 

集合型の使い方

#集合型を作る
tokuisakiA={‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’}
tokuisakiB={‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’J’}

#含まれないデータを抽出する・・①

tokuisakiA-tokuisakiB
>>> {‘H’, ‘I’}

#集合体の値を1つにまとめる・・②

tokuisakiA|tokuisakiB
>>> {‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’, ‘J’}

#共通する値の取得・・③

tokuisakiA & tokuisakiB
>>> {‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’}

#共通しない値の取得・・④

tokuisakiA^tokuisakiB
>>> {‘H’, ‘I’, ‘J’}

#所在の確認・・⑤
‘H’ in tokuisakiA
>>> True

‘H’ in tokuisakiB
>>> False

 

「tokuisakiA」と「tokuisakiB」という2つの集合型があります。

「tokuisakiA」には {‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’H’,’I’} が格納されています。
「tokuisakiB」には {‘A’,’B’,’C’,’D’,’E’,’F’,’G’,’J’}    が格納されています。

 

①A集合型からB集合型に含まれないデータを抽出します。
(「-」を使います)

tokuisakiA –  tokuisakiB
>>> {‘H’, ‘I’}

tokuisakiAのうち、tokuisakiBに含まれないデータは
「H」と「I」とわかりました。

 

②2つの集合型を1つにまとめます。
(「+」ではなく「 | 」を使います)

tokuisakiA|tokuisakiB
>>> {‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’, ‘H’, ‘I’, ‘J’}

2つの集合型が重複しないように1つにまとまりました。

 

③2つの集合型の共通する値を取得します。
(「&」を使います)

tokuisakiA & tokuisakiB
>>> {‘A’, ‘B’, ‘C’, ‘D’, ‘E’, ‘F’, ‘G’}

2つの集合型のうち重複しているデータを抽出しました。

 

④2つの集合型の共通しない値を取得します。
(「^」を使います)

tokuisakiA^tokuisakiB
>>> {‘H’, ‘I’, ‘J’}

2つの集合型のうち重複していないデータを抽出しました。

 

⑤それぞれの集合型のうち任意のデータ(H)が存在するかを確認します。

‘H’ in tokuisakiA
>>> True

「H」は「tokuisakiA」に存在していることがわかりました。

‘H’ in tokuisakiB
>>> False

「H」は「tokuisakiB」に存在していないことがわかりました。

 

Webサイトから情報を自動で抜き出す方法

財務では、経済情報、マーケット情報、株価・為替情報など逐次整理しておく必要があります。

情報源は一般的にはWebサイトになりますが、サイトにアクセスして情報を抜き出すにも手間がかかるため、これらの作業を自動化して業務効率を図ることが必要です。

集めた情報から分析、加工、データマイニング、そしてプレゼン資料にまとめるところまですべて自動化したいのですが、まずは初歩的なところから始めたいと思います。

財務など分析系にはpythonというプログラミング言語が最適ですので、pythonを利用して業務効率を図るにはどうすればよいかを考えていきます。

今回は、手始めにヤフーファイナンスから書かれている中見出し(h2)の題名を収集する方法を試してみました。

課題
指定したwebサイトから項目を抜き出し箇条書きで表示したい

Webページから第2項目(h2)を拾う

import requests
from bs4 import BeautifulSoup

url = “https://news.finance.yahoo.co.jp/”

rp = requests.get(url)

bs = BeautifulSoup(rp.text, ‘html.parser’)

for i in bs.select(“h2”):

 print(i.getText())

 

分析したいWebページのアドレスをurl = ”           ” の中に埋め込みます。

Webページのアドレスがurl変数に代入され、requests.get()の引数に渡すことによりWebサイトのデータを取得し、変数rpに代入します。

requests.get(url)で取得したデータをテキストとしてBeautiful Soupに渡しただけで、HTMLを解析してくれます。

このコードではh2のタグを選んで全て表示させています。

第二引数の「html.parser」はHTMLでパースをするということを設定しています。
bs.select(“h2”)でh2のタグを指定して、for文を回すことでそれぞれのタイトルを抽出することが出来ました。

抽出結果

経済総合

市況・概況

日本株

外国株

産業

雑誌・コラム

【PR】Yahoo!ファイナンスからのお知らせ

不動産投資コラム(楽待)

ヘッドライン

総合アクセスランキング

マーケット情報