Python

2023.08.03

Pythonは、オランダ出身のグイド・ヴァンロッサム(Guido van Rossum)氏により開発されました。Pythonという名称は、グイド氏がファンであった「空飛ぶモンティ・パイソン」という英国のコメディ番組に由来します。PythonはAIの流行で人気を集めるようになりました。

特徴
  • 様々な環境で利用できる
  • 多くのライブラリが開発されており利用者は簡単に利用することができる
  • 他の多くのプログラム言語と異なる文法で、特にインデントを使ってコードブロックを定義する点や、動的型付けを採用している
用途
  • 数値計算（Numpy、SciPy）
  • データ分析（Pandas、Matplotlib）
  • AI（機械学習）（scikit-learn、TensorFlow）
  • データベース(SQLiteやMySQL、PostgreSQLといったデータベースの接続ライブラリ）
  • Webアプリケーション（Bottle、Flask、Djangoなど)

数値

＋加算
－減算
＊乗算
／除算
／／除算(結果は整数)
％剰余(除算の余り)
＊＊べき乗
優先度
↑ 高い
＊＊
＊, ／, ／／, ％
＋, －
↓低い

文字列

文字列を扱うさいは、シングルクォーテーション「'」もしくは、ダブルクォーテーション「"」で囲みます。文字列は、＋ で結合したり、＊で繰り返えさせたりすることができる。

"That's right."
'That\'s right.'
'<a href="about.html">'
'Long' * 2 + 'Ago' →　LongLongAgo
print(len('four'))
---
4

シングルクォーテーションやダブルクォーテーション自体を文字列として扱い場合には、￥（英語モードではバックスラッシュ）でエスケープすることで表現します。またエスケープ記号である￥自体も￥でエスケープします。この時の文字出力の制御を行う特殊な文字￥の事をエスケープシーケンスと呼びます。

エスケープシーケンスの例
￥￥円記号（英語モードではバックスラッシュ）
￥’シングルクォーテーション
￥”ダブルクォーテーション
￥ｎ改行
￥ｔタブ

変数

変数と代入

変数　＝　値 
変数　＝　式

変数名は、1文字目は半角の英文字にする。2文字目以降は半角の英文字か数字にする。単語の区切りは「＿」であらわす。

tax = 0.1
price_excluding_tax = 2500
Price_including_tax = price_excluding_tax * (1  + tax)

複合演算子

＋＝加算a += 1
ー＝減算a -= 1
＊＝乗算a *= 2
／＝除算a /= 3
／／＝除算(結果は整数)a //= 2
％＝剰余a %= 3
＊＊＝べき乗a **= 3

インデスクとスライス

インデスク

指定した文字列から文字を取り出す。

文字列[インデスク]

x = 'abcde'
print(x[3])
---
'd'
print(x[-1])
---
'e'

スライス

文字列の一部から文字列を取り出す。

文字列[開始インデクス:終了インデスク]
変数[開始インデクス:終了インデスク]
式[開始インデクス:終了インデスク]
a = 'ApplePie'
print(a[5:8])
---
'Pie'
文字列[:終了]先頭から「終了」で指定した位置ー１まで
文字列[開始:]「開始」で指定した位置から末尾まで
文字列[:]すべて

リスト

複数の要素を確認できるデータ構造

[値, …]

初期化

menu = ['apple', 'orange', 'melon']

インデクス

menu = ['apple', 'orange', 'melon']
print(menu[1])
---
'orange'
print(menu[-1])
---
'melon'
menu[1] = 'pineapple'
print(menu[1])
---
'pineapple'

スライス

print(menu[1:3])
---
'orange', 'pineapple'
print(menu[:2])
---
['apple', 'orange']
print(menu[2:])
---
['melon']
print(menu[::2])
---
['apple', 'melon']

print(menu[::-1])
---
['melon', 'orange', 'apple']
リスト[開始インデクス:終了インデクス]
リスト[開始インデクス:終了インデクス:ステップ]

追加・挿入・削除・取出し・カウント・検索・ソート

メソッドを使ってリストの値を操作する

リスト[インデスク] = 値インデクスの位置の値を上書きする
リスト.append(値)リストの末尾に要素を追加
リスト.insert(インデクス, 値)指定した位置に要素を挿入
リスト.remove(値)指定した値を持つ最初の要素を削除
リスト.pop(インデクス)インデクスの位置の値を取出して削除
リスト.index(検索対象, 開始位置)検索対象を開始位置から探索して見つかったインデクス値
リスト.count(検索対象)リスト内に検索対象が存在する個数
リスト.sort(reverse=True)リストをソートする。reverse=Trueで逆順
len(リスト)要素数を取得
del リストリストを削除する
menu.append('melon')
print(menu)
---
'apple', 'orange', 'pineapple', 'melon'
menu.remove('pineapple')
print(menu)
---
'apple', 'orange', 'melon'
menu.insert(2, 'melon')
print(menu)
---
'apple', 'orange', 'melon', 'pineapple'
print(len(menu))
---
4

ミュータブルとイミュータブル

リストはミュータブル(値の変更が可能)だが、文字列はイミュータブル(値の変更が出来ない)

ネスト

menu = ['apple', 'orange', 'melon']
num = [1, 2, 3]
x = [menu, num]
print(x)
---
[['apple', 'orange', 'melon'], [1, 2, 3]]
print(x[0])
---
['apple', 'orange', 'melon']
print(x[1][1])
---
2

その他

l = list('abcdefg')
print(l)
---
['a', 'b', 'c', 'd', 'e', 'f', 'g']
if 'e' in l:
    print('exist')
---
exist
s = 'a b c d e'
to_split = s.split(' ')
print(to_split)
---
['a', 'b', 'c', 'd', 'e']
to_join = ' '.join(to_split)
print(to_join)
---
a b c d e
print(help(list))
---
リストのメソッドとその説明が表示される

リストの結合

リスト1 + リスト2リスト1とリスト2を連結したリストを返す
リスト1 += リスト2リスト1にリスト2を結合する
list1 = ['a', 'b', 'c']
list2 = ['d', 'e', 'f']
list3 = list1 + list2
print(list3)
---
'a', 'b', 'c', 'd', 'e', 'f'
a = [1, 2, 3]
b = [4, 5, 6]
x = a + b
print(x)
---
[1, 2, 3, 4, 5, 6]
a += b
print(a)
---
[1, 2, 3, 4, 5, 6]
a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
---
[1, 2, 3, 4, 5, 6]

リストのコピーと値渡し・参照渡し

代入すると参照渡しになるので、値渡しにしたい場合はcopy()を用いる。

a = [1, 2, 3]
b = a
b[0] = 100
print('b = ', b)
print('a = ', a)
---
b =  [100, 2, 3]
a =  [100, 2, 3]
※参照渡しになってる
a = [1, 2, 3]
b = a.copy()
b[0] = 100
print('b = ', b)
print('a = ', a)
---
b =  [100, 2, 3]
a =  [1, 2, 3]
※値渡しが出来ている

値のオブジェクトのIDを見てみると、参照では同じ、値渡しでは別の物であることを確認することが出来る。

a = [1, 2, 3]
b = a
print('b = ', id(b))
print('a = ', id(a))
---
b = 131848810742528
a = 131848810742528
a = [1, 2, 3]
b = a.copy()
print('b = ', id(b))
print('a = ', id(a))
---
b =  131848823337792
a =  131848810742528

タプル

リストと同様に複数の要素を格納できるイミュータブルなデータ構造でインデックスやスライスも同様に扱える。

(値, …)
t = ('apple', 250)
print(t)
---
('apple', 250)
print(t[0])
---
'apple'
print(t[0:2])
---
('apple', 250)

パック

タプルを変数に代入する事。この際（）を省略できる

t = 'apple', 250
print(t)
---
('apple', 250)

アンパック

変数から値を取り出す

fruits, price = t
print(fruits)
---
'apple'

リストとタプル

menu = [('apple', 250), ('melon', 600)]
print(menu)
---
('apple', 250), ('melon', 600)

集合

集合はリストやタプルと同様に複数の要素を格納できるデータ構造でミュータブルである。重複する要素は格納できない。要素の順番が保証できない。要素の有無を高速に調べられる。

初期化

｛値, …}
fruits = {'apple', 'melon', 'orange'}
print(fruits)
---
'apple', 'melon', 'orange'

in演算子とnot in演算子

値 in 集合
値 not in 集合
print('apple' in fruits)
---
True
print('apple' not in fruits)
---
False

要素の追加と削除

要素の追加
集合 ｜＝　｛値,   … }
fruits |= {'pineapple'}
print(fruites)
---
{'apple', 'melon', 'orange', 'pineapple'}
要素からの削除
集合　－＝　{ 値, …　}
fruits -= {'orange'}
print(fruites)
---
{'apple', 'melon', 'pineapple'}
集合の演算
集合A　＆　集合B積集合（集合Aと集合Bに共通する要素）
集合A　｜　集合B和集合（集合Aと集合Bのすべての要素）
集合A　－　集合B差集合（集合Aから集合Bを削除した集合）
集合A　＾　集合B対象差（集合Aまたは集合Bの一方だけが含む要素）

辞書（＝連想配列）

2つの値をペアにして登録する、複数の要素を格納できるデータ構造。一方の値をキーと呼ぶ。キーを使ってもう一歩運バリューにアクセスできる。

｛キー：値,　…｝
menu = { 'apple': 250, 'melon': 600 }
print(menu)
---
{ 'apple': 250, 'melon': 600 }
menu = dict( apple = 250, melon = 600 )
print(menu)
---
{ 'apple': 250, 'melon': 600 }

要素の追加と変更

辞書[キー] = 値
menu['orange'] = 100
print(menu)
---
{ 'apple': 250, 'melon': 600, 'orange': 100 }

要素の削除

del 辞書[キー]
del menu['apple']
print(menu)
{'melon': 600 }

要素の有無

キー in 辞書
キー not in 辞書
print('apple' in menu)
---
True
print('apple' not in menu)
---
False

キーの取出し

menu = { 'apple': 250, 'melon': 600 }
menu.key()
---
dict_keys(['apple', 'melon'])

キーとバリューの取出し

menu = { 'apple': 250, 'melon': 600 }
for k in menu.keys():
  print('KEY:', k, ' VAL:', menu[k])
---
KEY: apple  VAL: 250
KEY: melon  VAL: 600

制御構文

ｉｆ文

ｉｆ　式Ａ：
　　式ＡがＴｒｕｅの時の処理
ｅｌｉｆ　式Ｂ：
　　式ＢがＴｒｕｅの時の処理
ｅｌｓｅ：
　　式Ａも式ＢもFalseの時の処理
if a > 0:
    print('plus')
elif a < 0:
    print('minus')
else:
    print('zero')
a == baとb が等しければ True
a != baとb が異なれば True
a < baがb より小さい時 True
a > baがb より大きい時 True
a <= baがb以下の時 True
a >= baがb以上の時 True
X and YX かつ Y
X or YX または Y
not XX ではない

　　

ｆｏｒ文

ｆｏｒ 変数　ｉｎ　イテラブル：
　　処理
　　…

イテラブル(iterable)は、繰り返し対象にできるオブジェクトで、例えば文字列、リスト、タプル、集合、辞書などを言う。ｆｏｒ文はこのイテラブルから値を1つ取り出すごとに処理を実行し、取り出せる値がなくなるまで繰り返す。

menu = {'apple', 'orange', 'melon'}
for i in menu:
    print(i)
---
apple
orange
melon
range(終了値)
range(開始値, 終了値)
range(開始値, 終了値, ステップ)

開始値から(開始値を省略した場合は0から)終了値までステップ値(省略した場合は１)ずつ増加する整数を生成する。

for i in range(1, 10, 2):
    print(i, end=' ')
---
1 3 5 7 9 
for i in range(3, 15)
    print(i % 12 + 1, end=','
---
4,5,6,7,8,9,10,11,12,1,2,3

ｗｈｉｌｅ文

ｗｈｉｌｅ　式：
　　処理
　　…

条件に基づいて繰り返しを行う。

i = 0
while i < 100:
  print(i, end=' ')
  i += 2

break文とcontinue文とelse

for  変数 in イテラブル:
    if 式:
        break
    if 式:
        continue
else:
    処理
while  式:
    if 式:
        break
    if 式:
        continue
else:
    処理

breakは繰り返し処理を中断しループから抜け出す。continueは繰り返し処理の以降の処理をせず次の処理のために先頭に戻る。else部は、forもしくはwhileがbreakで終了しなかった時に処理されます。

for i in range(1,3):
  if i == 3:
    break
else:
  print(i)

関数

関数の定義

ｄｅｆ　関数名（引数，…）：
　　処理
　　…
　　ｒｅｔｕｒｎ　戻り値
  • def： 関数を定義する時に用いるキーワード。definition(定義)の略
  • 関数名： 関数の名前。命名は変数の規則と同じ
  • 引数： 関数に渡す値。0個でも複数でも可能。位置もしくはキーワードで引数を渡すことが出来る
  • インデント： 関数内で処理する内容はインデントが必要。複数行で記載できる
  • return文： 呼び出し元に戻り値を伴って処理が戻る
def add(x, y):
    return x+y
print(add(2, 3))
---
5
print(add(y=3, x=2))
---
5

スコープ

変数のスコープ
  • グローバル変数： 関数の外側で兵議した変数でそのファイル全体がスコープとなり関数の内部・外部両方で使える
  • ローカル変数： 関数の内側で定義した変数でその関数の内側がスコープになり、関数の内側でだけ使える
x = 10
def f():
    print(x)

print(f())
---
10
def f():
    x = 10

print(x)
---
NameError: name 'x' is not defined

global文とnonlocal文
def f():
    global x
    x = 10

x = 20
f()
print(x)
---
10
def f():
    def g():
        nonlocal x
        x = 10
    x = 20
    g()
    print(x)
f()
---
10

オブジェクト

クラスという構成を使い、　複数のデータをまとめて取り扱ったり、保持しているデータに対してメソッドという処理を介してデータにアクセスする仕組み。

Pythonにおいては、文字列や関数、各種のデータ構造(リスト・タプル・集合・辞書)もオプジェクトの一種である。

オブジェクトに属するデータや処理の構成を定義するためにクラスという仕組みを用い得る。クラスは設計図にオブジェクトは製品に例えることができます。

クラス

クラスでは3つのオブジェクト型と新たな意味づけをいくつか取り入れている。

クラス定義の構文

クラス定義は以下のような形式になります。

class ClassName:
    <statement-1>
    ...
    <statement-N>

クラス定義内は新たな名前空間が作成される。クラス内のstatementには関数を定義することで機能を定義できます。それをメソッドと呼びます。

クラスオブジェクトは、属性参照とインスタンス生成をサポートしています。

クラス定義が効果を持つには実行する必要があります。

obj = ClassName()

これでクラスの新しいインスタンスを生成し、そのオブジェクトをローカル変数obj へ代入しています。この際に空のオブジェクトが作成される。__init__() というメソッドを定義することで生成時に初期状態を定義させることができます。この際のメソッドを特別にコンストラクタと呼びます。

属性参照は、上記の例で表現すると、クラス内のstatementを、ClassName.statement-1 のようにそのクラスに属しているステートメントを参照することができます。

クラスの例

データ（属性）とそれを操作する処理（メソッド）をまとめた設計図（テンプレート）。

class MyClass:
    def __init__(self, name='anonymous'):
        self.name = name

    def get_name(self):
        return 'hello ' + self.name + '.'
obj1 = MyClass()
print(obj1.get_name())

obj2 = MyClass('hoge')
print(obj2.get_name())

出力結果
hello anonymous.
hello hoge.

継承

既存のクラスを変更することなく、既存のクラスを再利用したり拡張したりするメカニズム。

class MyClassJob(MyClass):
    def __init__(self name='anonymous', job='unemployed'):
        super().__init__(name)
        self.job = job

    def get_job(self):
        return self.name + ' is ' + self.job + '.'
obj = MyClassJob('hoge', 'sales')
print(obj.get_job())

出力結果
anonymous is unemployed.
hoge is sales.

オーバーライド

オーバーライドとはクラスの継承時に親クラスのメソッドを上書きするクラス。子クラスを親クラスと同じ名前でメソッド名やメソッドの引数の数や順番も同一で定義します。

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        return "Woof!"

class Cat(Animal):
    def make_sound(self):
        return "Meow!"
dog = Dog()
print(dog.make_sound())

cat = Cat()
print(cat.make_sound())

出力結果
Woof!
Meow!
ホーム
プログラミング
Python
タイトルとURLをコピーしました